LibChecker.exe
----------------
A primitive Python Indentation-Checker.
Will also remove unused Characters from the right side of the Line.
Just start it to have "Library.py" identation checked.
Or Drag'n Drop the "Library.py" or any other ".py"-File on the LibChecker.exe
to have it checked for identation-Problems.

If there were Identing-Problems found a Window will open and show the Line-Numbers, 
that have been changed. If no window opens, there were possibly no seriouse problems.

LibChecker will create a "Backup.py" with the Library.py before the Process.
######################################################
Load_Image.exe
---------------
You will be prompted to choose a folder with pictures.
Then the Script will generate a Textfile "Outfile_01.txt"
Tis file will contain the Pythonm code to load all these pictures into Blender "as Images".
Copy the code and paste it into the System-COnsole to include all the pictures into Blender-Scene "as Images".
######################################################
Lib-Analyzer.exe
-----------------
Will generate a Textfile with an Inventory of all Procedures in the Library.py

######################################################
https://cgcookie.com/articles/blender-2-8-python-scripting-superpowers-for-non-programmers

bpy.app - Information about Blender itself that doesn’t change while running.
bpy.context - Read-only lists of what’s currently active in Blender. 
bpy.data - All of Blender’s internal data, such as objects.
bpy.msgbus - Stands for “message bus”, and is used for notifying Blender of certain changes. Not something we need to worry about. 
bpy.ops - All the operations you can do in Blender, from modeling to appending files to rendering. 
bpy.path - Functions that deal with file paths. 
bpy.props - The different properties that Blender uses. You’d use this to tell Blender whether an input should be a number or a color. 
bpy.types - Every type of thing that exists in Blender, from modifiers to textures to lamps and much more.
bpy.utils - Utility functions that are only for Blender but do not deal with internal data.






###########################################################
#Analyze Vertexes and Edges from Object
from Library import *

obj = Get_Active_Object()
data = obj.data

# FACES, TRIANGLES
total_triangles = 0

Poly=len(data.polygons)

for face in data.polygons:
    vertices = face.vertices
    triangles = len(vertices) - 2
    total_triangles += triangles

print("Vertices: "+str(vertices))
print("Polygons: "+str(Poly))
print("total Triangles: "+str(total_triangles))

"""
# VERTICES
vertices = []
for vertex in data.vertices:
    pos = [vertex.co[0], vertex.co[1], vertex.co[2]]
    vertices.append(pos)



# EDGES
edges = []
for edge in data.edges:
    edges.append([edge.vertices[0], edge.vertices[1]])
print(edges)

#########################################################
def getIndexOfFaces(name):
    """ Print the index of faces to the console

        - Switch to the edit-Mode
        - select faces
        - the output ist shown in the console
    """
    bpy.context.scene.objects.active = bpy.data.objects[name]
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.object.mode_set(mode='OBJECT')
    me = bpy.context.object.data
    for poly in me.polygons:
        if poly.select:
            print("Polygon index: %d, length: %d" % (poly.index,
                                                     poly.loop_total))
    bpy.ops.object.mode_set(mode='EDIT')
#########################################################
"""     

from Library import *

def AssembleOverrideContextForView3dOps():
    #=== Iterates through the blender GUI's windows, screens, areas, regions to find the View3D space and its associated window.  Populate an 'oContextOverride context' that can be used with bpy.ops that require to be used from within a View3D (like most addon code that runs of View3D panels)
    # Tip: If your operator fails the log will show an "PyContext: 'xyz' not found".  To fix stuff 'xyz' into the override context and try again!
    for oWindow in bpy.context.window_manager.windows:          ###IMPROVE: Find way to avoid doing four levels of traversals at every request!!
        oScreen = oWindow.screen
        for oArea in oScreen.areas:
            if oArea.type == 'VIEW_3D':                         ###LEARN: Frequently, bpy.ops operators are called from View3d's toolbox or property panel.  By finding that window/screen/area we can fool operators in thinking they were called from the View3D!
                for oRegion in oArea.regions:
                    if oRegion.type == 'WINDOW':                ###LEARN: View3D has several 'windows' like 'HEADER' and 'WINDOW'.  Most bpy.ops require 'WINDOW'
                        #=== Now that we've (finally!) found the damn View3D stuff all that into a dictionary bpy.ops operators can accept to specify their context.  I stuffed extra info in there like selected objects, active objects, etc as most operators require them.  (If anything is missing operator will fail and log a 'PyContext: error on the log with what is missing in context override) ===
                        oContextOverride = {'window': oWindow, 'screen': oScreen, 'area': oArea, 'region': oRegion, 'scene': bpy.context.scene, 'edit_object': bpy.context.edit_object, 'active_object': bpy.context.active_object, 'selected_objects': bpy.context.selected_objects}   # Stuff the override context with very common requests by operators.  MORE COULD BE NEEDED!
                        print("-AssembleOverrideContextForView3dOps() created override context: ", oContextOverride)
                        return oContextOverride
    raise Exception("ERROR: AssembleOverrideContextForView3dOps() could not find a VIEW_3D with WINDOW region to create override context to enable View3D operators.  Operator cannot function.")

def TestView3dOperatorFromPythonScript():       # Run this from a python script and operators that would normally fail because they were not called from a View3D context will work!
    oContextOverride = AssembleOverrideContextForView3dOps()    # Get an override context suitable for bpy.ops operators that require View3D
    bpy.ops.mesh.knife_project(oContextOverride)                # An operator like this normally requires to run off the View3D context.  By overriding it with what it needs it will run from any context (like Python script, Python shell, etc)
    #bpy.ops.screen.screen_full_area(oContextOverride)
    print("TestView3dOperatorFromPythonScript() completed succesfully.")
    
    
TestView3dOperatorFromPythonScript()
########################################################

def AssembleOverrideContextForView3dOps():
    #=== Iterates through the blender GUI's windows, screens, areas, regions to find the View3D space and its associated window.  Populate an 'oContextOverride context' that can be used with bpy.ops that require to be used from within a View3D (like most addon code that runs of View3D panels)
    # Tip: If your operator fails the log will show an "PyContext: 'xyz' not found".  To fix stuff 'xyz' into the override context and try again!
    for oWindow in bpy.context.window_manager.windows:          ###IMPROVE: Find way to avoid doing four levels of traversals at every request!!
        oScreen = oWindow.screen
        for oArea in oScreen.areas:
            if oArea.type == 'VIEW_3D':                         ###LEARN: Frequently, bpy.ops operators are called from View3d's toolbox or property panel.  By finding that window/screen/area we can fool operators in thinking they were called from the View3D!
               v3d_area = aArea
		space_data = v3d_area.spaces.active
		space_data.clip_end=1e6
#########################################################
# Simplify F-Curves by removing closely spaced keyframes
bpy.ops.action.clean(threshold=0.001)
# Select keyframes by clicking on them
bpy.ops.action.clickselect(extend=False, column=False)
# Copy selected keyframes to the copy/paste buffer
bpy.ops.action.copy()
# Remove all selected keyframes
bpy.ops.action.delete()
# Make a copy of all selected keyframes
bpy.ops.action.duplicate()
# Make a copy of all selected keyframes and move them
bpy.ops.action.duplicate_move(ACTION_OT_duplicate={}, TRANSFORM_OT_transform={“mode”:’TRANSLATION’, “value”:(0, 0, 0, 0), “axis”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “release_confirm”:False})
# Set extrapolation mode for selected F-Curves
bpy.ops.action.extrapolation_type(type=’CONSTANT’)
# Set the current frame to the average frame value of selected keyframes
bpy.ops.action.frame_jump()
# Set type of handle for selected keyframes
bpy.ops.action.handle_type(type=’FREE’)
# Set interpolation mode for the F-Curve segments starting from the selected keyframes
bpy.ops.action.interpolation_type(type=’CONSTANT’)
# Insert keyframes for the specified channels
bpy.ops.action.keyframe_insert(type=’ALL’)
# Set type of keyframe for the selected keyframes
bpy.ops.action.keyframe_type(type=’KEYFRAME’)
# Move selected scene markers to the active Action as local ‘pose’ markers
bpy.ops.action.markers_make_local()
# Flip selected keyframes over the selected mirror line
bpy.ops.action.mirror(type=’CFRA’)
# Create new action
bpy.ops.action.new()
# Paste keyframes from copy/paste buffer for the selected channels, starting on the current frame
bpy.ops.action.paste(offset=’START’, merge=’MIX’)
# Set Preview Range based on extents of selected Keyframes
bpy.ops.action.previewrange_set()
# Add keyframes on every frame between the selected keyframes
bpy.ops.action.sample()
# Toggle selection of all keyframes
bpy.ops.action.select_all_toggle(invert=False)
# Select all keyframes within the specified region
bpy.ops.action.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True, axis_range=False)
# Select all keyframes on the specified frame(s)
bpy.ops.action.select_column(mode=’KEYS’)
# Select keyframes to the left or the right of the current frame
bpy.ops.action.select_leftright(mode=’CHECK’, extend=False)
# Deselect keyframes on ends of selection islands
bpy.ops.action.select_less()
# Select keyframes occurring in the same F-Curves as selected ones
bpy.ops.action.select_linked()
# Select keyframes beside already selected ones
bpy.ops.action.select_more()
# Snap selected keyframes to the times specified
bpy.ops.action.snap(type=’CFRA’)
# Reset viewable area to show full keyframe range
bpy.ops.action.view_all()
# Reset viewable area to show selected keyframes range
bpy.ops.action.view_selected()
# Interactively change the current frame number
bpy.ops.anim.change_frame(frame=0)
# Handle mouse-clicks over animation channels
bpy.ops.anim.channels_click(extend=False, children_only=False)
# Collapse (i.e. close) all selected expandable animation channels
bpy.ops.anim.channels_collapse(all=True)
# Delete all selected animation channels
bpy.ops.anim.channels_delete()
# Toggle editability of selected channels
bpy.ops.anim.channels_editable_toggle(mode=’TOGGLE’, type=’PROTECT’)
# Expand (i.e. open) all selected expandable animation channels
bpy.ops.anim.channels_expand(all=True)
# Clears ‘disabled’ tag from all F-Curves to get broken F-Curves working again
bpy.ops.anim.channels_fcurves_enable()
# Add selected F-Curves to a new group
bpy.ops.anim.channels_group(name=”New Group”)
# Rearrange selected animation channels
bpy.ops.anim.channels_move(direction=’DOWN’)
# Rename animation channel under mouse
bpy.ops.anim.channels_rename()
# Toggle selection of all animation channels
bpy.ops.anim.channels_select_all_toggle(invert=False)
# Select all animation channels within the specified region
bpy.ops.anim.channels_select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Disable specified setting on all selected animation channels
bpy.ops.anim.channels_setting_disable(mode=’DISABLE’, type=’PROTECT’)
# Enable specified setting on all selected animation channels
bpy.ops.anim.channels_setting_enable(mode=’ENABLE’, type=’PROTECT’)
# Toggle specified setting on all selected animation channels
bpy.ops.anim.channels_setting_toggle(mode=’TOGGLE’, type=’PROTECT’)
# Remove selected F-Curves from their current groups
bpy.ops.anim.channels_ungroup()
# Make only the selected animation channels visible in the Graph Editor
bpy.ops.anim.channels_visibility_set()
# Toggle visibility in Graph Editor of all selected animation channels
bpy.ops.anim.channels_visibility_toggle()
# Mark actions with no F-Curves for deletion after save & reload of file preserving “action libraries”
bpy.ops.anim.clear_useless_actions(only_unused=True)
# Copy the driver for the highlighted button
bpy.ops.anim.copy_driver_button()
# Add driver(s) for the property(s) connected represented by the highlighted button
bpy.ops.anim.driver_button_add(all=True)
# Remove the driver(s) for the property(s) connected represented by the highlighted button
bpy.ops.anim.driver_button_remove(all=True)
# Clear all keyframes on the currently active property
bpy.ops.anim.keyframe_clear_button(all=True)
# Remove all keyframe animation for selected objects
bpy.ops.anim.keyframe_clear_v3d()
# Delete keyframes on the current frame for all properties in the specified Keying Set
bpy.ops.anim.keyframe_delete(type=’DEFAULT’, confirm_success=True)
# Delete current keyframe of current UI-active property
bpy.ops.anim.keyframe_delete_button(all=True)
# Remove keyframes on current frame for selected objects
bpy.ops.anim.keyframe_delete_v3d()
# Insert keyframes on the current frame for all properties in the specified Keying Set
bpy.ops.anim.keyframe_insert(type=’DEFAULT’, confirm_success=True)
# Insert a keyframe for current UI-active property
bpy.ops.anim.keyframe_insert_button(all=True)
# Insert Keyframes for specified Keying Set, with menu of available Keying Sets if undefined
bpy.ops.anim.keyframe_insert_menu(type=’DEFAULT’, confirm_success=False, always_prompt=False)
# Select a new keying set as the active one
bpy.ops.anim.keying_set_active_set(type=’DEFAULT’)
# Add a new (empty) Keying Set to the active Scene
bpy.ops.anim.keying_set_add()
# Export Keying Set to a python script
bpy.ops.anim.keying_set_export(filepath=””, filter_folder=True, filter_text=True, filter_python=True)
# Add empty path to active Keying Set
bpy.ops.anim.keying_set_path_add()
# Remove active Path from active Keying Set
bpy.ops.anim.keying_set_path_remove()
# Remove the active Keying Set
bpy.ops.anim.keying_set_remove()
# Add current UI-active property to current keying set
bpy.ops.anim.keyingset_button_add(all=True)
# Remove current UI-active property from current keying set
bpy.ops.anim.keyingset_button_remove()
# Paste the driver in the copy/paste buffer for the highlighted button
bpy.ops.anim.paste_driver_button()
# Clear Preview Range
bpy.ops.anim.previewrange_clear()
# Interactively define frame range used for playback
bpy.ops.anim.previewrange_set(xmin=0, xmax=0, ymin=0, ymax=0)
# Update data paths from 2.56 and previous versions, modifying data paths of drivers and fcurves
bpy.ops.anim.update_data_paths()
# Align selected bones to the active bone (or to their parent)
bpy.ops.armature.align()
# Change the visible armature layers
bpy.ops.armature.armature_layers(layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Automatically renames the selected bones according to which side of the target axis they fall on
bpy.ops.armature.autoside_names(type=’XAXIS’)
# Change the layers that the selected bones belong to
bpy.ops.armature.bone_layers(layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Add a new bone located at the 3D-Cursor
bpy.ops.armature.bone_primitive_add(name=”Bone”)
# Automatically fix alignment of select bones’ axes
bpy.ops.armature.calculate_roll(type=’X’, axis_flip=False, axis_only=False)
# Create a new bone going from the last selected joint to the mouse position
bpy.ops.armature.click_extrude()
# Remove selected bones from the armature
bpy.ops.armature.delete()
# Make copies of the selected bones within the same armature
bpy.ops.armature.duplicate()
# Make copies of the selected bones within the same armature and move them
bpy.ops.armature.duplicate_move(ARMATURE_OT_duplicate={}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Create new bones from the selected joints
bpy.ops.armature.extrude(forked=False)
# Create new bones from the selected joints and move them
bpy.ops.armature.extrude_forked(ARMATURE_OT_extrude={“forked”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Create new bones from the selected joints and move them
bpy.ops.armature.extrude_move(ARMATURE_OT_extrude={“forked”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Add bone between selected joint(s) and/or 3D-Cursor
bpy.ops.armature.fill()
# Flips (and corrects) the axis suffixes of the names of selected bones
bpy.ops.armature.flip_names()
# Tag selected bones to not be visible in Edit Mode
bpy.ops.armature.hide(unselected=False)
# Make all armature layers visible
bpy.ops.armature.layers_show_all(all=True)
# Merge continuous chains of selected bones
bpy.ops.armature.merge(type=’WITHIN_CHAIN’)
# Remove the parent-child relationship between selected bones and their parents
bpy.ops.armature.parent_clear(type=’CLEAR’)
# Set the active bone as the parent of the selected bones
bpy.ops.armature.parent_set(type=’CONNECTED’)
# Unhide all bones that have been tagged to be hidden in Edit Mode
bpy.ops.armature.reveal()
# Toggle selection status of all bones
bpy.ops.armature.select_all(action=’TOGGLE’)
# Select immediate parent/children of selected bones
bpy.ops.armature.select_hierarchy(direction=’PARENT’, extend=False)
# Flip the selection status of bones (selected -> unselected, unselected -> selected)
bpy.ops.armature.select_inverse()
# Select bones related to selected ones by parent/child relationships
bpy.ops.armature.select_linked(extend=False)
# Select similar bones by property types
bpy.ops.armature.select_similar(type=’LENGTH’, threshold=0.1)
# Isolate selected bones into a separate armature
bpy.ops.armature.separate()
# Break selected bones into chains of smaller bones
bpy.ops.armature.subdivide(number_cuts=1)
# Change the direction that a chain of bones points in (head <-> tail swap)
bpy.ops.armature.switch_direction()
# Add a boid rule to the current boid state
bpy.ops.boid.rule_add(type=’GOAL’)
# Delete current boid rule
bpy.ops.boid.rule_del()
# Move boid rule down in the list
bpy.ops.boid.rule_move_down()
# Move boid rule up in the list
bpy.ops.boid.rule_move_up()
# Add a boid state to the particle system
bpy.ops.boid.state_add()
# Delete current boid state
bpy.ops.boid.state_del()
# Move boid state down in the list
bpy.ops.boid.state_move_down()
# Move boid state up in the list
bpy.ops.boid.state_move_up()
# Set active sculpt/paint brush from it’s number
bpy.ops.brush.active_index_set(mode=””, index=0)
# Add brush by mode type
bpy.ops.brush.add()
# Set brush shape
bpy.ops.brush.curve_preset(shape=’SMOOTH’)
# Return brush to defaults based on current tool
bpy.ops.brush.reset()
# Change brush size by a scalar
bpy.ops.brush.scale_size(scalar=1)
# Control the stencil brush
bpy.ops.brush.stencil_control(mode=’TRANSLATION’, texmode=’PRIMARY’)
# When using an image texture, adjust the stencil size to fit the image aspect ratio
bpy.ops.brush.stencil_fit_image_aspect(use_repeat=True, use_scale=True, mask=False)
# Reset the stencil transformation to the default
bpy.ops.brush.stencil_reset_transform(mask=False)
# Set the UV sculpt tool
bpy.ops.brush.uv_sculpt_tool_set(tool=’PINCH’)
# Open a directory browser, Hold Shift to open the file, Alt to browse containing directory
bpy.ops.buttons.directory_browse(directory=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=False, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Open a file browser, Hold Shift to open the file, Alt to browse containing directory
bpy.ops.buttons.file_browse(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=False, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Display button panel toolbox
bpy.ops.buttons.toolbox()
# Add a Camera Preset
bpy.ops.camera.preset_add(remove_active=False, name=””)
# Place new marker at specified location
bpy.ops.clip.add_marker(location=(0, 0))
# Place new marker at the desired (clicked) position
bpy.ops.clip.add_marker_at_click()
# Add new marker and move it on movie
bpy.ops.clip.add_marker_move(CLIP_OT_add_marker={“location”:(0, 0)}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Add new marker and slide it with mouse until mouse button release
bpy.ops.clip.add_marker_slide(CLIP_OT_add_marker={“location”:(0, 0)}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Apply scale on solution itself to make distance between selected tracks equals to desired
bpy.ops.clip.apply_solution_scale(distance=0)
# Create vertex cloud using coordinates of reconstructed tracks
bpy.ops.clip.bundles_to_mesh()
# Add a Tracking Camera Intrinsics Preset
bpy.ops.clip.camera_preset_add(remove_active=False, name=””)
# Interactively change the current frame number
bpy.ops.clip.change_frame(frame=0)
# Clean tracks with high error values or few frames
bpy.ops.clip.clean_tracks(frames=0, error=0, action=’SELECT’)
# Clear all calculated data
bpy.ops.clip.clear_solution()
# Clear tracks after/before current position or clear the whole track
bpy.ops.clip.clear_track_path(action=’REMAINED’, clear_active=False)
# Create F-Curves for object which will copy object’s movement caused by this constraint
bpy.ops.clip.constraint_to_fcurve()
# Copy selected tracks to clipboard
bpy.ops.clip.copy_tracks()
# Delete marker for current frame from selected tracks
bpy.ops.clip.delete_marker()
# Delete movie clip proxy files from the hard drive
bpy.ops.clip.delete_proxy()
# Delete selected tracks
bpy.ops.clip.delete_track()
# Automatically detect features and place markers to track
bpy.ops.clip.detect_features(placement=’FRAME’, margin=16, min_trackability=16, min_distance=120)
# Disable/enable selected markers
bpy.ops.clip.disable_markers(action=’DISABLE’)
# Select movie tracking channel
bpy.ops.clip.dopesheet_select_channel(location=(0, 0), extend=False)
# Reset viewable area to show full keyframe range
bpy.ops.clip.dopesheet_view_all()
# Jump to special frame
bpy.ops.clip.frame_jump(position=’PATHSTART’)
# Scroll view so current frame would be centered
bpy.ops.clip.graph_center_current_frame()
# Delete selected curves
bpy.ops.clip.graph_delete_curve()
# Delete curve knots
bpy.ops.clip.graph_delete_knot()
# Disable/enable selected markers
bpy.ops.clip.graph_disable_markers(action=’DISABLE’)
# Select graph curves
bpy.ops.clip.graph_select(location=(0, 0), extend=False)
# Change selection of all markers of active track
bpy.ops.clip.graph_select_all_markers(action=’TOGGLE’)
# Select curve points using border selection
bpy.ops.clip.graph_select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# View all curves in editor
bpy.ops.clip.graph_view_all()
# Hide selected tracks
bpy.ops.clip.hide_tracks(unselected=False)
# Clear hide selected tracks
bpy.ops.clip.hide_tracks_clear()
# Join selected tracks
bpy.ops.clip.join_tracks()
# Lock/unlock selected tracks
bpy.ops.clip.lock_tracks(action=’LOCK’)
# Set the clip interaction mode
bpy.ops.clip.mode_set(mode=’TRACKING’)
# Load a sequence of frames or a movie file
bpy.ops.clip.open(directory=””, files=[], filter_blender=False, filter_backup=False, filter_image=True, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Paste tracks from clipboard
bpy.ops.clip.paste_tracks()
# Prefetch frames from disk for faster playback/tracking
bpy.ops.clip.prefetch()
# Toggle clip properties panel
bpy.ops.clip.properties()
# Rebuild all selected proxies and timecode indices in the background
bpy.ops.clip.rebuild_proxy()
# Refine selected markers positions by running the tracker from track’s reference to current frame
bpy.ops.clip.refine_markers(backwards=False)
# Reload clip
bpy.ops.clip.reload()
# Select tracking markers
bpy.ops.clip.select(extend=False, location=(0, 0))
# Change selection of all tracking markers
bpy.ops.clip.select_all(action=’TOGGLE’)
# Select markers using border selection
bpy.ops.clip.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select markers using circle selection
bpy.ops.clip.select_circle(x=0, y=0, radius=0, gesture_mode=0)
# Select all tracks from specified group
bpy.ops.clip.select_grouped(group=’ESTIMATED’)
# Select markers using lasso selection
bpy.ops.clip.select_lasso(path=[], deselect=False, extend=True)
# Set direction of scene axis rotating camera (or it’s parent if present) and assuming selected track lies on real axis joining it with the origin
bpy.ops.clip.set_axis(axis=’X’)
# Set optical center to center of footage
bpy.ops.clip.set_center_principal()
# Set active marker as origin by moving camera (or it’s parent if present) in 3D space
bpy.ops.clip.set_origin(use_median=False)
# Set plane based on 3 selected bundles by moving camera (or it’s parent if present) in 3D space
bpy.ops.clip.set_plane(plane=’FLOOR’)
# Set scale of scene by scaling camera (or it’s parent if present)
bpy.ops.clip.set_scale(distance=0)
# Set scene’s start and end frame to match clip’s start frame and length
bpy.ops.clip.set_scene_frames()
# Set object solution scale using distance between two selected tracks
bpy.ops.clip.set_solution_scale(distance=0)
# Set keyframe used by solver
bpy.ops.clip.set_solver_keyframe(keyframe=’KEYFRAME_A’)
# Set current movie clip as a camera background in 3D view-port (works only when a 3D view-port is visible)
bpy.ops.clip.set_viewport_background()
# Prepare scene for compositing 3D objects into this footage
bpy.ops.clip.setup_tracking_scene()
# Slide marker areas
bpy.ops.clip.slide_marker(offset=(0, 0))
# Solve camera motion from tracks
bpy.ops.clip.solve_camera()
# Add selected tracks to 2D stabilization tool
bpy.ops.clip.stabilize_2d_add()
# Remove selected track from stabilization
bpy.ops.clip.stabilize_2d_remove()
# Select track which are used for stabilization
bpy.ops.clip.stabilize_2d_select()
# Use active track to compensate rotation when doing 2D stabilization
bpy.ops.clip.stabilize_2d_set_rotation()
# Toggle clip tools panel
bpy.ops.clip.tools()
# Add a Clip Track Color Preset
bpy.ops.clip.track_color_preset_add(remove_active=False, name=””)
# Copy color to all selected tracks
bpy.ops.clip.track_copy_color()
# Track selected markers
bpy.ops.clip.track_markers(backwards=False, sequence=False)
# Copy tracking settings from active track to default settings
bpy.ops.clip.track_settings_as_default()
# Create an Empty object which will be copying movement of active track
bpy.ops.clip.track_to_empty()
# Add new object for tracking
bpy.ops.clip.tracking_object_new()
# Remove object for tracking
bpy.ops.clip.tracking_object_remove()
# Add a motion tracking settings preset
bpy.ops.clip.tracking_settings_preset_add(remove_active=False, name=””)
# View whole image with markers
bpy.ops.clip.view_all(fit_view=False)
# Use a 3D mouse device to pan/zoom the view
bpy.ops.clip.view_ndof()
# Pan the view
bpy.ops.clip.view_pan(offset=(0, 0))
# View all selected elements
bpy.ops.clip.view_selected()
# Zoom in/out the view
bpy.ops.clip.view_zoom(factor=0)
# Zoom in the view
bpy.ops.clip.view_zoom_in(location=(0, 0))
# Zoom out the view
bpy.ops.clip.view_zoom_out(location=(0, 0))
# Set the zoom ratio (based on clip size)
bpy.ops.clip.view_zoom_ratio(ratio=0)
# Add a Cloth Preset
bpy.ops.cloth.preset_add(remove_active=False, name=””)
# Evaluate the namespace up until the cursor and give a list of options or complete the name if there is only one
bpy.ops.console.autocomplete()
# Print a message when the terminal initializes
bpy.ops.console.banner()
# Clear text by type
bpy.ops.console.clear(scrollback=True, history=False)
# Clear the line and store in history
bpy.ops.console.clear_line()
# Copy selected text to clipboard
bpy.ops.console.copy()
# Copy the console contents for use in a script
bpy.ops.console.copy_as_script()
# Delete text by cursor position
bpy.ops.console.delete(type=’NEXT_CHARACTER’)
# Execute the current console line as a python expression
bpy.ops.console.execute(interactive=False)
# Append history at cursor position
bpy.ops.console.history_append(text=””, current_character=0, remove_duplicates=False)
# Cycle through history
bpy.ops.console.history_cycle(reverse=False)
# Add 4 spaces at line beginning
bpy.ops.console.indent()
# Insert text at cursor position
bpy.ops.console.insert(text=””)
# Set the current language for this console
bpy.ops.console.language(language=””)
# Move cursor position
bpy.ops.console.move(type=’LINE_BEGIN’)
# Paste text from clipboard
bpy.ops.console.paste()
# Append scrollback text by type
bpy.ops.console.scrollback_append(text=””, type=’OUTPUT’)
# Set the console selection
bpy.ops.console.select_set()
# Delete 4 spaces from line beginning
bpy.ops.console.unindent()
# Clear inverse correction for ChildOf constraint
bpy.ops.constraint.childof_clear_inverse(constraint=””, owner=’OBJECT’)
# Set inverse correction for ChildOf constraint
bpy.ops.constraint.childof_set_inverse(constraint=””, owner=’OBJECT’)
# Remove constraint from constraint stack
bpy.ops.constraint.delete()
# Add default animation for path used by constraint if it isn’t animated already
bpy.ops.constraint.followpath_path_animate(constraint=””, owner=’OBJECT’, frame_start=1, length=100)
# Reset limiting distance for Limit Distance Constraint
bpy.ops.constraint.limitdistance_reset(constraint=””, owner=’OBJECT’)
# Move constraint down in constraint stack
bpy.ops.constraint.move_down(constraint=””, owner=’OBJECT’)
# Move constraint up in constraint stack
bpy.ops.constraint.move_up(constraint=””, owner=’OBJECT’)
# Clear inverse correction for ObjectSolver constraint
bpy.ops.constraint.objectsolver_clear_inverse(constraint=””, owner=’OBJECT’)
# Set inverse correction for ObjectSolver constraint
bpy.ops.constraint.objectsolver_set_inverse(constraint=””, owner=’OBJECT’)
# Reset original length of bone for Stretch To Constraint
bpy.ops.constraint.stretchto_reset(constraint=””, owner=’OBJECT’)
# Make active spline closed/opened loop
bpy.ops.curve.cyclic_toggle(direction=’CYCLIC_U’)
# (De)select first of visible part of each NURBS
bpy.ops.curve.de_select_first()
# (De)select last of visible part of each NURBS
bpy.ops.curve.de_select_last()
# Delete selected control points or segments
bpy.ops.curve.delete(type=’SELECTED’)
# Duplicate selected control points and segments between them
bpy.ops.curve.duplicate()
# Duplicate curve and move
bpy.ops.curve.duplicate_move(CURVE_OT_duplicate={}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Extrude selected control point(s)
bpy.ops.curve.extrude(mode=’TRANSLATION’)
# Extrude curve and move result
bpy.ops.curve.extrude_move(CURVE_OT_extrude={“mode”:’TRANSLATION’}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Set type of handles for selected control points
bpy.ops.curve.handle_type_set(type=’AUTOMATIC’)
# Hide (un)selected control points
bpy.ops.curve.hide(unselected=False)
# Join two curves by their selected ends
bpy.ops.curve.make_segment()
# Construct a Bezier Circle
bpy.ops.curve.primitive_bezier_circle_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Bezier Curve
bpy.ops.curve.primitive_bezier_curve_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs Circle
bpy.ops.curve.primitive_nurbs_circle_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs Curve
bpy.ops.curve.primitive_nurbs_curve_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Path
bpy.ops.curve.primitive_nurbs_path_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Set per-point radius which is used for bevel tapering
bpy.ops.curve.radius_set(radius=1)
# Show again hidden control points
bpy.ops.curve.reveal()
# (De)select all control points
bpy.ops.curve.select_all(action=’TOGGLE’)
# Reduce current selection by deselecting boundary elements
bpy.ops.curve.select_less()
# Select all control points linked to active one
bpy.ops.curve.select_linked()
# Select all control points linked to already selected ones
bpy.ops.curve.select_linked_pick(deselect=False)
# Select control points directly linked to already selected ones
bpy.ops.curve.select_more()
# Select control points following already selected ones along the curves
bpy.ops.curve.select_next()
# Deselect every other vertex
bpy.ops.curve.select_nth(nth=2)
# Select control points preceding already selected ones along the curves
bpy.ops.curve.select_previous()
# Randomly select some control points
bpy.ops.curve.select_random(percent=50, extend=False)
# Select a row of control points including active one
bpy.ops.curve.select_row()
# Separate (partly) selected curves or surfaces into a new object
bpy.ops.curve.separate()
# Set shading to flat
bpy.ops.curve.shade_flat()
# Set shading to smooth
bpy.ops.curve.shade_smooth()
# Flatten angles of selected points
bpy.ops.curve.smooth()
# Flatten radii of selected points
bpy.ops.curve.smooth_radius()
# Extrude selected boundary row around pivot point and current view axis
bpy.ops.curve.spin(center=(0, 0, 0), axis=(0, 0, 0))
# Set type of active spline
bpy.ops.curve.spline_type_set(type=’POLY’, use_handles=False)
# Set softbody goal weight for selected points
bpy.ops.curve.spline_weight_set(weight=1)
# Subdivide selected segments
bpy.ops.curve.subdivide(number_cuts=1)
# Switch direction of selected splines
bpy.ops.curve.switch_direction()
# Clear the tilt of selected control points
bpy.ops.curve.tilt_clear()
# Add a new control point (linked to only selected end-curve one, if any)
bpy.ops.curve.vertex_add(location=(0, 0, 0))
# Enable nodes on a material, world or lamp
bpy.ops.cycles.use_shading_nodes()
# Bake dynamic paint image sequence surface
bpy.ops.dpaint.bake()
# Add or remove Dynamic Paint output data layer
bpy.ops.dpaint.output_toggle(output=’A’)
# Add a new Dynamic Paint surface slot
bpy.ops.dpaint.surface_slot_add()
# Remove the selected surface slot
bpy.ops.dpaint.surface_slot_remove()
# Toggle whether given type is active or not
bpy.ops.dpaint.type_toggle(type=’CANVAS’)
# Redo previous action
bpy.ops.ed.redo()
# Undo previous action
bpy.ops.ed.undo()
# Redo specific action in history
bpy.ops.ed.undo_history(item=0)
# Add an undo state (internal use only)
bpy.ops.ed.undo_push(message=”Add an undo step function may be moved”)
# Save a BVH motion capture file from an armature
bpy.ops.export_anim.bvh(check_existing=True, filepath=””, filter_glob=”*.bvh”, global_scale=1, frame_start=0, frame_end=0, rotate_mode=’NATIVE’, root_transform_only=False)
# Export a single object as a Stanford PLY with normals, colors and texture coordinates
bpy.ops.export_mesh.ply(check_existing=True, filepath=””, filter_glob=”*.ply”, use_mesh_modifiers=True, use_normals=True, use_uv_coords=True, use_colors=True, axis_forward=’Y’, axis_up=’Z’, global_scale=1)
# Save STL triangle mesh data from the active object
bpy.ops.export_mesh.stl(check_existing=True, filepath=””, filter_glob=”*.stl”, ascii=False, use_mesh_modifiers=True, axis_forward=’Y’, axis_up=’Z’, global_scale=1)
# Export to 3DS file format (.3ds)
bpy.ops.export_scene.autodesk_3ds(check_existing=True, filepath=””, filter_glob=”*.3ds”, use_selection=False, axis_forward=’Y’, axis_up=’Z’)
# Selection to an ASCII Autodesk FBX
bpy.ops.export_scene.fbx(check_existing=True, filepath=””, filter_glob=”*.fbx”, use_selection=False, global_scale=1, axis_forward=’-Z’, axis_up=’Y’, object_types={‘EMPTY’, ‘CAMERA’, ‘LAMP’, ‘ARMATURE’, ‘MESH’}, use_mesh_modifiers=True, mesh_smooth_type=’FACE’, use_mesh_edges=False, use_armature_deform_only=False, use_anim=True, use_anim_action_all=True, use_default_take=True, use_anim_optimize=True, anim_optimize_precision=6, path_mode=’AUTO’, use_rotate_workaround=False, xna_validate=False, batch_mode=’OFF’, use_batch_own_dir=True, use_metadata=True)
# Save a Wavefront OBJ File
bpy.ops.export_scene.obj(check_existing=True, filepath=””, filter_glob=”.obj;.mtl”, use_selection=False, use_animation=False, use_mesh_modifiers=True, use_edges=True, use_smooth_groups=False, use_normals=False, use_uvs=True, use_materials=True, use_triangles=False, use_nurbs=False, use_vertex_groups=False, use_blen_objects=True, group_by_object=False, group_by_material=False, keep_vertex_order=False, axis_forward=’-Z’, axis_up=’Y’, global_scale=1, path_mode=’AUTO’)
# Export selection to Extensible 3D file (.x3d)
bpy.ops.export_scene.x3d(check_existing=True, filepath=””, filter_glob=”*.x3d”, use_selection=False, use_mesh_modifiers=True, use_triangulate=False, use_normals=False, use_compress=False, use_hierarchy=True, name_decorations=True, use_h3d=False, axis_forward=’Z’, axis_up=’Y’, global_scale=1, path_mode=’AUTO’)
# Add a bookmark for the selected/active directory
bpy.ops.file.bookmark_add()
# Toggle bookmarks display
bpy.ops.file.bookmark_toggle()
# Cancel loading of selected file
bpy.ops.file.cancel()
# Delete selected files
bpy.ops.file.delete()
# Delete selected bookmark
bpy.ops.file.delete_bookmark(index=-1)
# Enter a directory name
bpy.ops.file.directory()
# Create a new directory
bpy.ops.file.directory_new(directory=””)
# Execute selected file
bpy.ops.file.execute(need_active=False)
# Increment number in filename
bpy.ops.file.filenum(increment=1)
# Try to find missing external files
bpy.ops.file.find_missing_files(find_all=False, directory=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=False, filemode=9, display_type=’FILE_DEFAULTDISPLAY’)
# Toggle hide hidden dot files
bpy.ops.file.hidedot()
# Highlight selected file(s)
bpy.ops.file.highlight()
# Make all paths to external files absolute
bpy.ops.file.make_paths_absolute()
# Make all paths to external files relative to current .blend
bpy.ops.file.make_paths_relative()
# Move to next folder
bpy.ops.file.next()
# Pack all used external files into the .blend
bpy.ops.file.pack_all()
# Pack all used Blender library files into the current .blend
bpy.ops.file.pack_libraries()
# Move to parent directory
bpy.ops.file.parent()
# Move to previous folder
bpy.ops.file.previous()
# Refresh the file list
bpy.ops.file.refresh()
# Rename file or file directory
bpy.ops.file.rename()
# Report all missing external files
bpy.ops.file.report_missing_files()
# Reset Recent files
bpy.ops.file.reset_recent()
# Activate/select file
bpy.ops.file.select(extend=False, fill=False, open=True)
# Select or deselect all files
bpy.ops.file.select_all_toggle()
# Select a bookmarked directory
bpy.ops.file.select_bookmark(dir=””)
# Activate/select the file(s) contained in the border
bpy.ops.file.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Smooth scroll to make editable file visible
bpy.ops.file.smoothscroll()
# Unpack all files packed into this .blend to external ones
bpy.ops.file.unpack_all(method=’USE_LOCAL’)
# Unpack this file to an external file
bpy.ops.file.unpack_item(method=’USE_LOCAL’, id_name=””, id_type=19785)
# Unpack all used Blender library files from this .blend file
bpy.ops.file.unpack_libraries()
# Bake fluid simulation
bpy.ops.fluid.bake()
# Add a Fluid Preset
bpy.ops.fluid.preset_add(remove_active=False, name=””)
# Set font case
bpy.ops.font.case_set(case=’LOWER’)
# Toggle font case
bpy.ops.font.case_toggle()
# Change font character code
bpy.ops.font.change_character(delta=1)
# Change font spacing
bpy.ops.font.change_spacing(delta=1)
# Delete text by cursor position
bpy.ops.font.delete(type=’ALL’)
# Paste contents from file
bpy.ops.font.file_paste(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=True, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’)
# Insert placeholder text
bpy.ops.font.insert_lorem()
# Insert line break at cursor position
bpy.ops.font.line_break()
# Move cursor to position type
bpy.ops.font.move(type=’LINE_BEGIN’)
# Make selection from current cursor position to new cursor position type
bpy.ops.font.move_select(type=’LINE_BEGIN’)
# Load a new font from a file
bpy.ops.font.open(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=True, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Set font style
bpy.ops.font.style_set(style=’BOLD’, clear=False)
# Toggle font style
bpy.ops.font.style_toggle(style=’BOLD’)
# Copy selected text to clipboard
bpy.ops.font.text_copy()
# Cut selected text to clipboard
bpy.ops.font.text_cut()
# Insert text at cursor position
bpy.ops.font.text_insert(text=””, accent=False)
# Paste text from clipboard
bpy.ops.font.text_paste()
# Add a new text box
bpy.ops.font.textbox_add()
# Remove the textbox
bpy.ops.font.textbox_remove(index=0)
# Unlink active font data block
bpy.ops.font.unlink()
# Delete the active frame for the active Grease Pencil datablock
bpy.ops.gpencil.active_frame_delete()
# Convert the active Grease Pencil layer to a new Curve Object
bpy.ops.gpencil.convert(type=’PATH’, use_normalize_weights=True, radius_multiplier=1, use_link_strokes=True, timing_mode=’<UNKNOWN ENUM>’, frame_range=100, start_frame=1, use_realtime=False, end_frame=250, gap_duration=0, gap_randomness=0, seed=0, use_timing_data=False)
# Add new Grease Pencil datablock
bpy.ops.gpencil.data_add()
# Unlink active Grease Pencil datablock
bpy.ops.gpencil.data_unlink()
# Make annotations on the active data
bpy.ops.gpencil.draw(mode=’DRAW’, stroke=[])
# Add new Grease Pencil layer for the active Grease Pencil datablock
bpy.ops.gpencil.layer_add()
# Bake selected F-Curves to a set of sampled points defining a similar curve
bpy.ops.graph.bake()
# Simplify F-Curves by removing closely spaced keyframes
bpy.ops.graph.clean(threshold=0.001)
# Insert new keyframe at the cursor position for the active F-Curve
bpy.ops.graph.click_insert(frame=1, value=1)
# Select keyframes by clicking on them
bpy.ops.graph.clickselect(extend=False, column=False, curves=False)
# Copy selected keyframes to the copy/paste buffer
bpy.ops.graph.copy()
# Interactively set the current frame number and value cursor
bpy.ops.graph.cursor_set(frame=0, value=0)
# Remove all selected keyframes
bpy.ops.graph.delete()
# Make a copy of all selected keyframes
bpy.ops.graph.duplicate(mode=’TRANSLATION’)
# Make a copy of all selected keyframes and move them
bpy.ops.graph.duplicate_move(GRAPH_OT_duplicate={“mode”:’TRANSLATION’}, TRANSFORM_OT_transform={“mode”:’TRANSLATION’, “value”:(0, 0, 0, 0), “axis”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “release_confirm”:False})
# Fix large jumps and flips in the selected Euler Rotation F-Curves arising from rotation values being clipped when baking physics
bpy.ops.graph.euler_filter()
# Set extrapolation mode for selected F-Curves
bpy.ops.graph.extrapolation_type(type=’CONSTANT’)
# Add F-Modifiers to the selected F-Curves
bpy.ops.graph.fmodifier_add(type=’NULL’, only_active=True)
# Copy the F-Modifier(s) of the active F-Curve
bpy.ops.graph.fmodifier_copy()
# Add copied F-Modifiers to the selected F-Curves
bpy.ops.graph.fmodifier_paste()
# Place the cursor on the midpoint of selected keyframes
bpy.ops.graph.frame_jump()
# Clear F-Curve snapshots (Ghosts) for active Graph Editor
bpy.ops.graph.ghost_curves_clear()
# Create snapshot (Ghosts) of selected F-Curves as background aid for active Graph Editor
bpy.ops.graph.ghost_curves_create()
# Set type of handle for selected keyframes
bpy.ops.graph.handle_type(type=’FREE’)
# Set interpolation mode for the F-Curve segments starting from the selected keyframes
bpy.ops.graph.interpolation_type(type=’CONSTANT’)
# Insert keyframes for the specified channels
bpy.ops.graph.keyframe_insert(type=’ALL’)
# Flip selected keyframes over the selected mirror line
bpy.ops.graph.mirror(type=’CFRA’)
# Paste keyframes from copy/paste buffer for the selected channels, starting on the current frame
bpy.ops.graph.paste(offset=’START’, merge=’MIX’)
# Automatically set Preview Range based on range of keyframes
bpy.ops.graph.previewrange_set()
# Toggle display properties panel
bpy.ops.graph.properties()
# Add keyframes on every frame between the selected keyframes
bpy.ops.graph.sample()
# Toggle selection of all keyframes
bpy.ops.graph.select_all_toggle(invert=False)
# Select all keyframes within the specified region
bpy.ops.graph.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True, axis_range=False, include_handles=False)
# Select all keyframes on the specified frame(s)
bpy.ops.graph.select_column(mode=’KEYS’)
# Select keyframes to the left or the right of the current frame
bpy.ops.graph.select_leftright(mode=’CHECK’, extend=False)
# Deselect keyframes on ends of selection islands
bpy.ops.graph.select_less()
# Select keyframes occurring in the same F-Curves as selected ones
bpy.ops.graph.select_linked()
# Select keyframes beside already selected ones
bpy.ops.graph.select_more()
# Apply weighted moving means to make selected F-Curves less bumpy
bpy.ops.graph.smooth()
# Snap selected keyframes to the chosen times/values
bpy.ops.graph.snap(type=’CFRA’)
# Bakes a sound wave to selected F-Curves
bpy.ops.graph.sound_bake(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=True, filter_python=False, filter_font=False, filter_sound=True, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’, low=0, high=100000, attack=0.005, release=0.2, threshold=0, use_accumulate=False, use_additive=False, use_square=False, sthreshold=0.1)
# Reset viewable area to show full keyframe range
bpy.ops.graph.view_all(include_handles=True)
# Reset viewable area to show selected keyframe range
bpy.ops.graph.view_selected(include_handles=True)
# Create an object group from selected objects
bpy.ops.group.create(name=”Group”)
# Add the object to an object group that contains the active object
bpy.ops.group.objects_add_active(group=’<UNKNOWN ENUM>’)
# Remove selected objects from all groups or a selected group
bpy.ops.group.objects_remove(group=’<UNKNOWN ENUM>’)
# Remove the object from an object group that contains the active object
bpy.ops.group.objects_remove_active()
# Remove selected objects from all groups or a selected group
bpy.ops.group.objects_remove_all()
# Set black point or white point for curves
bpy.ops.image.curves_point_set(point=’BLACK_POINT’)
# Cycle through all non-void render slots
bpy.ops.image.cycle_render_slot(reverse=False)
# Edit image in an external application
bpy.ops.image.external_edit(filepath=””)
# Invert image’s channels
bpy.ops.image.invert(invert_r=False, invert_g=False, invert_b=False, invert_a=False)
# Set image’s user’s length to the one of this video
bpy.ops.image.match_movie_length()
# Create a new image
bpy.ops.image.new(name=”Untitled”, width=1024, height=1024, color=(0, 0, 0, 1), alpha=True, generated_type=’BLANK’, float=False)
# Open image
bpy.ops.image.open(filepath=””, filter_blender=False, filter_backup=False, filter_image=True, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Pack an image as embedded data into the .blend file
bpy.ops.image.pack(as_png=False)
# Project edited image back onto the object
bpy.ops.image.project_apply()
# Edit a snapshot of the view-port in an external image editor
bpy.ops.image.project_edit()
# Toggle display properties panel
bpy.ops.image.properties()
# Reload current image from disk
bpy.ops.image.reload()
# Replace current image by another one from disk
bpy.ops.image.replace(filepath=””, filter_blender=False, filter_backup=False, filter_image=True, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Use mouse to sample a color in current image
bpy.ops.image.sample()
# Sample a line and show it in Scope panels
bpy.ops.image.sample_line(xstart=0, xend=0, ystart=0, yend=0, cursor=1)
# Save the image with current name and settings
bpy.ops.image.save()
# Save the image with another name and/or settings
bpy.ops.image.save_as(save_as_render=False, copy=False, filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=True, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
# Save all modified textures
bpy.ops.image.save_dirty()
# Save a sequence of images
bpy.ops.image.save_sequence()
# Toggle display scopes panel
bpy.ops.image.scopes()
# Save an image packed in the .blend file to disk
bpy.ops.image.unpack(method=’USE_LOCAL’, id=””)
# View the entire image
bpy.ops.image.view_all()
# Use a 3D mouse device to pan/zoom the view
bpy.ops.image.view_ndof()
# Pan the view
bpy.ops.image.view_pan(offset=(0, 0))
# View all selected UVs
bpy.ops.image.view_selected()
# Zoom in/out the image
bpy.ops.image.view_zoom(factor=0)
# Zoom in the image (centered around 2D cursor)
bpy.ops.image.view_zoom_in(location=(0, 0))
# Zoom out the image (centered around 2D cursor)
bpy.ops.image.view_zoom_out(location=(0, 0))
# Set zoom ratio of the view
bpy.ops.image.view_zoom_ratio(ratio=0)
# Load a BVH motion capture file
bpy.ops.import_anim.bvh(filepath=””, filter_glob=”*.bvh”, target=’ARMATURE’, global_scale=1, frame_start=1, use_fps_scale=False, use_cyclic=False, rotate_mode=’NATIVE’, axis_forward=’-Z’, axis_up=’Y’)
# Load a SVG file
bpy.ops.import_curve.svg(filepath=””, filter_glob=”*.svg”)
# Load a PLY geometry file
bpy.ops.import_mesh.ply(filepath=””, files=[], directory=””, filter_glob=”*.ply”)
# Load STL triangle mesh data
bpy.ops.import_mesh.stl(filepath=””, filter_glob=”*.stl”, files=[], directory=””)
# Import from 3DS file format (.3ds)
bpy.ops.import_scene.autodesk_3ds(filepath=””, filter_glob=”*.3ds”, constrain_size=10, use_image_search=True, use_apply_transform=True, axis_forward=’Y’, axis_up=’Z’)
# Load a Wavefront OBJ File
bpy.ops.import_scene.obj(filepath=””, filter_glob=”.obj;.mtl”, use_ngons=True, use_edges=True, use_smooth_groups=True, use_split_objects=True, use_split_groups=True, use_groups_as_vgroups=False, use_image_search=True, split_mode=’ON’, global_clamp_size=0, axis_forward=’-Z’, axis_up=’Y’)
# Import an X3D or VRML2 file
bpy.ops.import_scene.x3d(filepath=””, filter_glob=”.x3d;.wrl”, axis_forward=’Z’, axis_up=’Y’)
# Copy selected reports to Clipboard
bpy.ops.info.report_copy()
# Delete selected reports
bpy.ops.info.report_delete()
# Replay selected reports
bpy.ops.info.report_replay()
# Update the display of reports in Blender UI (internal use)
bpy.ops.info.reports_display_update()
# Select or deselect all reports
bpy.ops.info.select_all_toggle()
# Toggle border selection
bpy.ops.info.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select reports by index
bpy.ops.info.select_pick(report_index=0)
# Add a Sky & Atmosphere Preset
bpy.ops.lamp.sunsky_preset_add(remove_active=False, name=””)
# Mirror all control points without inverting the lattice deform
bpy.ops.lattice.flip(axis=’U’)
# Set UVW control points a uniform distance apart
bpy.ops.lattice.make_regular()
# Change selection of all UVW control points
bpy.ops.lattice.select_all(action=’TOGGLE’)
# Select vertices without a group
bpy.ops.lattice.select_ungrouped(extend=False)
# Add an actuator to the active object
bpy.ops.logic.actuator_add(type=’MOTION’, name=””, object=””)
# Move Actuator
bpy.ops.logic.actuator_move(actuator=””, object=””, direction=’UP’)
# Remove an actuator from the active object
bpy.ops.logic.actuator_remove(actuator=””, object=””)
# Add a controller to the active object
bpy.ops.logic.controller_add(type=’LOGIC_AND’, name=””, object=””)
# Move Controller
bpy.ops.logic.controller_move(controller=””, object=””, direction=’UP’)
# Remove a controller from the active object
bpy.ops.logic.controller_remove(controller=””, object=””)
# Remove logic brick connections
bpy.ops.logic.links_cut(path=[], cursor=9)
# Toggle display properties panel
bpy.ops.logic.properties()
# Add a sensor to the active object
bpy.ops.logic.sensor_add(type=’ALWAYS’, name=””, object=””)
# Move Sensor
bpy.ops.logic.sensor_move(sensor=””, object=””, direction=’UP’)
# Remove a sensor from the active object
bpy.ops.logic.sensor_remove(sensor=””, object=””)
# Convert old texface settings into material. It may create new materials if needed
bpy.ops.logic.texface_convert()
# Resize view so you can see all logic bricks
bpy.ops.logic.view_all()
# Add a new time marker
bpy.ops.marker.add()
# Bind the active camera to selected markers(s)
bpy.ops.marker.camera_bind()
# Delete selected time marker(s)
bpy.ops.marker.delete()
# Duplicate selected time marker(s)
bpy.ops.marker.duplicate(frames=0)
# Copy selected markers to another scene
bpy.ops.marker.make_links_scene(scene=’Scene’)
# Move selected time marker(s)
bpy.ops.marker.move(frames=0)
# Rename first selected time marker
bpy.ops.marker.rename(name=”RenamedMarker”)
# Select time marker(s)
bpy.ops.marker.select(extend=False, camera=False)
# Change selection of all time markers
bpy.ops.marker.select_all(action=’TOGGLE’)
# Select all time markers using border selection
bpy.ops.marker.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Add vertex to feather
bpy.ops.mask.add_feather_vertex(location=(0, 0))
# Add new vertex to feather and slide it
bpy.ops.mask.add_feather_vertex_slide(MASK_OT_add_feather_vertex={“location”:(0, 0)}, MASK_OT_slide_point={“slide_feather”:False})
# Add vertex to active spline
bpy.ops.mask.add_vertex(location=(0, 0))
# Add new vertex and slide it
bpy.ops.mask.add_vertex_slide(MASK_OT_add_vertex={“location”:(0, 0)}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Toggle cyclic for selected splines
bpy.ops.mask.cyclic_toggle()
# Delete selected control points or splines
bpy.ops.mask.delete()
# Reset the feather weight to zero
bpy.ops.mask.feather_weight_clear()
# Set type of handles for selected control points
bpy.ops.mask.handle_type_set(type=’AUTO’)
# Reveal the layer by setting the hide flag
bpy.ops.mask.hide_view_clear()
# Hide the layer by setting the hide flag
bpy.ops.mask.hide_view_set(unselected=False)
# Move the active layer up/down in the list
bpy.ops.mask.layer_move(direction=’UP’)
# Add new mask layer for masking
bpy.ops.mask.layer_new(name=””)
# Remove mask layer
bpy.ops.mask.layer_remove()
# Create new mask
bpy.ops.mask.new(name=””)
# Re-calculate the direction of selected handles
bpy.ops.mask.normals_make_consistent()
# Clear the mask’s parenting
bpy.ops.mask.parent_clear()
# Set the mask’s parenting
bpy.ops.mask.parent_set()
# Select spline points
bpy.ops.mask.select(extend=False, deselect=False, toggle=False, location=(0, 0))
# Change selection of all curve points
bpy.ops.mask.select_all(action=’TOGGLE’)
# Select markers using border selection
bpy.ops.mask.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select markers using circle selection
bpy.ops.mask.select_circle(x=0, y=0, radius=0, gesture_mode=0)
# Select markers using lasso selection
bpy.ops.mask.select_lasso(path=[], deselect=False, extend=True)
# Select all vertices linked to the active mesh
bpy.ops.mask.select_linked()
# (De)select all points linked to the curve under the mouse cursor
bpy.ops.mask.select_linked_pick(deselect=False)
#
bpy.ops.mask.shape_key_clear()
# Reset feather weights on all selected points animation values
bpy.ops.mask.shape_key_feather_reset()
#
bpy.ops.mask.shape_key_insert()
# Recalculate animation data on selected points for frames selected in the dopesheet
bpy.ops.mask.shape_key_rekey(location=True, feather=True)
# Slide control points
bpy.ops.mask.slide_point(slide_feather=False)
# Switch direction of selected splines
bpy.ops.mask.switch_direction()
# Copy the material settings and nodes
bpy.ops.material.copy()
# Add a new material
bpy.ops.material.new()
# Paste the material settings and nodes
bpy.ops.material.paste()
# Add a Subsurface Scattering Preset
bpy.ops.material.sss_preset_add(remove_active=False, name=””)
# Delete selected metaelement(s)
bpy.ops.mball.delete_metaelems()
# Duplicate selected metaelement(s)
bpy.ops.mball.duplicate_metaelems(mode=’TRANSLATION’)
# Hide (un)selected metaelement(s)
bpy.ops.mball.hide_metaelems(unselected=False)
# Reveal all hidden metaelements
bpy.ops.mball.reveal_metaelems()
# Change selection of all meta elements
bpy.ops.mball.select_all(action=’TOGGLE’)
# Randomly select metaelements
bpy.ops.mball.select_random_metaelems(percent=0.5)
# Rearrange some faces to try to get less degenerated geometry
bpy.ops.mesh.beautify_fill()
# Edge Bevel
bpy.ops.mesh.bevel(offset=0, segments=1, vertex_only=False)
# Blend in shape from a shape key
bpy.ops.mesh.blend_from_shape(shape=’<UNKNOWN ENUM>’, blend=1, add=True)
# Make faces between two or more edge loops
bpy.ops.mesh.bridge_edge_loops(type=’SINGLE’, use_merge=False, merge_factor=0.5, number_cuts=0, interpolation=’PATH’, smoothness=1, profile_shape_factor=0, profile_shape=’SMOOTH’)
# Flip direction of vertex colors inside faces
bpy.ops.mesh.colors_reverse()
# Rotate vertex colors inside faces
bpy.ops.mesh.colors_rotate(use_ccw=False)
# Enclose selected vertices in a convex polyhedron
bpy.ops.mesh.convex_hull(delete_unused=True, use_existing_faces=True, make_holes=False, join_triangles=True, limit=0.698132, uvs=False, vcols=False, sharp=False, materials=False)
# Clear vertex sculpt masking data from the mesh
bpy.ops.mesh.customdata_clear_mask()
# Clear vertex skin layer
bpy.ops.mesh.customdata_clear_skin()
# Delete selected vertices, edges or faces
bpy.ops.mesh.delete(type=’VERT’)
# Delete an edge loop by merging the faces on each side
bpy.ops.mesh.delete_edgeloop(use_face_split=True)
# Dissolve geometry
bpy.ops.mesh.dissolve_edges(use_verts=False, use_face_split=False)
# Dissolve geometry
bpy.ops.mesh.dissolve_faces(use_verts=False)
# Dissolve selected edges and verts, limited by the angle of surrounding geometry
bpy.ops.mesh.dissolve_limited(angle_limit=0.0872665, use_dissolve_boundaries=False, delimit=set())
# Dissolve geometry
bpy.ops.mesh.dissolve_verts(use_face_split=False)
# Assign Image to active UV Map, or create an UV Map
bpy.ops.mesh.drop_named_image(name=”Image”, filepath=”Path”)
# Duplicate and extrude selected vertices, edges or faces towards the mouse cursor
bpy.ops.mesh.dupli_extrude_cursor(rotate_source=True)
# Duplicate selected vertices, edges or faces
bpy.ops.mesh.duplicate(mode=1)
# Duplicate mesh and move
bpy.ops.mesh.duplicate_move(MESH_OT_duplicate={“mode”:1}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Collapse selected edges
bpy.ops.mesh.edge_collapse()
# Add an edge or face to selected
bpy.ops.mesh.edge_face_add()
# Rotate selected edge or adjoining faces
bpy.ops.mesh.edge_rotate(use_ccw=False)
# Split selected edges so that each neighbor face gets its own copy
bpy.ops.mesh.edge_split()
# Select an edge ring
bpy.ops.mesh.edgering_select(extend=False, deselect=False, toggle=False, ring=True)
# Select all sharp-enough edges
bpy.ops.mesh.edges_select_sharp(sharpness=0.523599)
# Extrude individual edges only
bpy.ops.mesh.extrude_edges_indiv(mirror=False)
# Extrude edges and move result
bpy.ops.mesh.extrude_edges_move(MESH_OT_extrude_edges_indiv={“mirror”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Extrude individual faces only
bpy.ops.mesh.extrude_faces_indiv(mirror=False)
# Extrude faces and move result
bpy.ops.mesh.extrude_faces_move(MESH_OT_extrude_faces_indiv={“mirror”:False}, TRANSFORM_OT_shrink_fatten={“value”:0, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “release_confirm”:False})
# Extrude region of faces
bpy.ops.mesh.extrude_region(mirror=False)
# Extrude region and move result
bpy.ops.mesh.extrude_region_move(MESH_OT_extrude_region={“mirror”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Extrude selected vertices, edges or faces repeatedly
bpy.ops.mesh.extrude_repeat(offset=2, steps=10)
# Extrude vertices and move result
bpy.ops.mesh.extrude_vertices_move(MESH_OT_extrude_verts_indiv={“mirror”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Extrude individual vertices only
bpy.ops.mesh.extrude_verts_indiv(mirror=False)
# Copy mirror UV coordinates on the X axis based on a mirrored mesh
bpy.ops.mesh.faces_mirror_uv(direction=’POSITIVE’, precision=3)
# Select linked faces by angle
bpy.ops.mesh.faces_select_linked_flat(sharpness=0.0174533)
# Display faces flat
bpy.ops.mesh.faces_shade_flat()
# Display faces smooth (using vertex normals)
bpy.ops.mesh.faces_shade_smooth()
# Fill a selected edge loop with faces
bpy.ops.mesh.fill(use_beauty=True)
# Fill grid from two loops
bpy.ops.mesh.fill_grid()
# Flip the direction of selected faces’ normals (and of their vertices)
bpy.ops.mesh.flip_normals()
# Hide (un)selected vertices, edges or faces
bpy.ops.mesh.hide(unselected=False)
# Inset new faces into selected faces
bpy.ops.mesh.inset(use_boundary=True, use_even_offset=True, use_relative_offset=False, thickness=0.01, depth=0, use_outset=False, use_select_inset=True, use_individual=False, use_interpolate=True)
# Use other objects outlines & boundaries to project knife cuts
bpy.ops.mesh.knife_project()
# Cut new topology
bpy.ops.mesh.knife_tool(use_occlude_geometry=True, only_selected=False)
# Select a loop of connected edges by connection type
bpy.ops.mesh.loop_multi_select(ring=False)
# Select a loop of connected edges
bpy.ops.mesh.loop_select(extend=False, deselect=False, toggle=False, ring=False)
# Select region of faces inside of a selected loop of edges
bpy.ops.mesh.loop_to_region(select_bigger=False)
# Add a new loop between existing loops
bpy.ops.mesh.loopcut(number_cuts=1, smoothness=0, falloff=’ROOT’, edge_index=-1, mesh_select_mode_init=(False, False, False))
# Cut mesh loop and slide it
bpy.ops.mesh.loopcut_slide(MESH_OT_loopcut={“number_cuts”:1, “smoothness”:0, “falloff”:’ROOT’, “edge_index”:-1, “mesh_select_mode_init”:(False, False, False)}, TRANSFORM_OT_edge_slide={“value”:0, “mirror”:False, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “correct_uv”:False, “release_confirm”:False})
# (Un)mark selected edges as Freestyle feature edges
bpy.ops.mesh.mark_freestyle_edge(clear=False)
# (Un)mark selected faces for exclusion from Freestyle feature edge detection
bpy.ops.mesh.mark_freestyle_face(clear=False)
# (Un)mark selected edges as a seam
bpy.ops.mesh.mark_seam(clear=False)
# (Un)mark selected edges as sharp
bpy.ops.mesh.mark_sharp(clear=False)
# Merge selected vertices
bpy.ops.mesh.merge(type=’CENTER’, uvs=False)
# Remove navmesh data from this mesh
bpy.ops.mesh.navmesh_clear()
# Add a new index and assign it to selected faces
bpy.ops.mesh.navmesh_face_add()
# Copy the index from the active face
bpy.ops.mesh.navmesh_face_copy()
# Create navigation mesh for selected objects
bpy.ops.mesh.navmesh_make()
# Assign a new index to every face
bpy.ops.mesh.navmesh_reset()
# Use vertex coordinate as texture coordinate
bpy.ops.mesh.noise(factor=0.1)
# Make face and vertex normals point either outside or inside the mesh
bpy.ops.mesh.normals_make_consistent(inside=False)
# Split a face into a fan
bpy.ops.mesh.poke(offset=0, use_relative_offset=False, center_mode=’MEAN_WEIGHTED’)
# Construct a circle mesh
bpy.ops.mesh.primitive_circle_add(vertices=32, radius=1, fill_type=’NOTHING’, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a conic mesh
bpy.ops.mesh.primitive_cone_add(vertices=32, radius1=1, radius2=0, depth=2, end_fill_type=’NGON’, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a cube mesh
bpy.ops.mesh.primitive_cube_add(radius=1, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a cylinder mesh
bpy.ops.mesh.primitive_cylinder_add(vertices=32, radius=1, depth=2, end_fill_type=’NGON’, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a grid mesh
bpy.ops.mesh.primitive_grid_add(x_subdivisions=10, y_subdivisions=10, radius=1, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct an Icosphere mesh
bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=2, size=1, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Suzanne mesh
bpy.ops.mesh.primitive_monkey_add(radius=1, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a filled planar mesh with 4 vertices
bpy.ops.mesh.primitive_plane_add(radius=1, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Add a torus mesh
bpy.ops.mesh.primitive_torus_add(rotation=(0, 0, 0), view_align=False, location=(0, 0, 0), major_radius=1, minor_radius=0.25, major_segments=48, minor_segments=12, use_abso=False, abso_major_rad=1, abso_minor_rad=0.5)
# Construct a UV sphere mesh
bpy.ops.mesh.primitive_uv_sphere_add(segments=32, ring_count=16, size=1, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Triangulate selected faces
bpy.ops.mesh.quads_convert_to_tris(use_beauty=True)
# Select boundary edges around the selected faces
bpy.ops.mesh.region_to_loop()
# Remove duplicate vertices
bpy.ops.mesh.remove_doubles(threshold=0.0001, use_unselected=False)
# Reveal all hidden vertices, edges and faces
bpy.ops.mesh.reveal()
# Disconnect vertex or edges from connected geometry
bpy.ops.mesh.rip(mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, release_confirm=False, use_fill=False)
# Rip polygons and move the result
bpy.ops.mesh.rip_move(MESH_OT_rip={“mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “release_confirm”:False, “use_fill”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Rip-fill polygons and move the result
bpy.ops.mesh.rip_move_fill(MESH_OT_rip={“mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “release_confirm”:False, “use_fill”:False}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Extrude selected vertices in screw-shaped rotation around the cursor in indicated viewport
bpy.ops.mesh.screw(steps=9, turns=1, center=(0, 0, 0), axis=(0, 0, 0))
# (De)select all vertices, edges or faces
bpy.ops.mesh.select_all(action=’TOGGLE’)
# Select all data in the mesh on a single axis
bpy.ops.mesh.select_axis(mode=’POSITIVE’, axis=’X_AXIS’)
# Select vertices or faces by the number of polygon sides
bpy.ops.mesh.select_face_by_sides(number=4, type=’EQUAL’, extend=True)
# Select faces where all edges have more than 2 face users
bpy.ops.mesh.select_interior_faces()
# Deselect vertices, edges or faces at the boundary of each selection region
bpy.ops.mesh.select_less()
# Select all vertices linked to the active mesh
bpy.ops.mesh.select_linked(limit=False)
# (De)select all vertices linked to the edge under the mouse cursor
bpy.ops.mesh.select_linked_pick(deselect=False, limit=False)
# Select loose geometry based on the selection mode
bpy.ops.mesh.select_loose(extend=False)
# Select mesh items at mirrored locations
bpy.ops.mesh.select_mirror(extend=False)
# Change selection mode
bpy.ops.mesh.select_mode(use_extend=False, use_expand=False, type=’VERT’, action=’TOGGLE’)
# Select more vertices, edges or faces connected to initial selection
bpy.ops.mesh.select_more()
# Select next edge loop adjacent to a selected loop
bpy.ops.mesh.select_next_loop()
# Select all non-manifold vertices or edges
bpy.ops.mesh.select_non_manifold(extend=True)
# Deselect every Nth element starting from the active vertex, edge or face
bpy.ops.mesh.select_nth(nth=2, offset=0)
# Randomly select vertices
bpy.ops.mesh.select_random(percent=50, extend=False)
# Select similar vertices, edges or faces by property types
bpy.ops.mesh.select_similar(type=’NORMAL’, compare=’EQUAL’, threshold=0)
# Select vertices without a group
bpy.ops.mesh.select_ungrouped(extend=False)
# Separate selected geometry into a new mesh
bpy.ops.mesh.separate(type=’SELECTED’)
# Apply selected vertex locations to all other shape keys
bpy.ops.mesh.shape_propagate_to_all()
# Select shortest path between two selections
bpy.ops.mesh.shortest_path_pick(extend=False)
# Selected vertex path between two vertices
bpy.ops.mesh.shortest_path_select(use_length=True)
# Create a solid skin by extruding, compensating for sharp angles
bpy.ops.mesh.solidify(thickness=0.01)
# The order of selected vertices/edges/faces is modified, based on a given method
bpy.ops.mesh.sort_elements(type=’VIEW_ZAXIS’, elements=set(), reverse=False, seed=0)
# Extrude selected vertices in a circle around the cursor in indicated viewport
bpy.ops.mesh.spin(steps=9, dupli=False, angle=1.5708, center=(0, 0, 0), axis=(0, 0, 0))
# Split off selected geometry from connected unselected geometry
bpy.ops.mesh.split()
# Subdivide selected edges
bpy.ops.mesh.subdivide(number_cuts=1, smoothness=0, quadtri=False, quadcorner=’STRAIGHT_CUT’, fractal=0, fractal_along_normal=0, seed=0)
#
bpy.ops.mesh.subdivide_edgering(number_cuts=10, interpolation=’PATH’, smoothness=1, profile_shape_factor=0, profile_shape=’SMOOTH’)
# Enforce symmetry (both form and topological) across an axis
bpy.ops.mesh.symmetrize(direction=’NEGATIVE_X’)
# Snap vertex pairs to their mirrored locations
bpy.ops.mesh.symmetry_snap(direction=’NEGATIVE_X’, threshold=0.05, factor=0.5, use_center=True)
# Join triangles into quads
bpy.ops.mesh.tris_convert_to_quads(limit=0.698132, uvs=False, vcols=False, sharp=False, materials=False)
# UnSubdivide selected edges & faces
bpy.ops.mesh.unsubdivide(iterations=2)
# Add UV Map
bpy.ops.mesh.uv_texture_add()
# Remove UV Map
bpy.ops.mesh.uv_texture_remove()
# Flip direction of UV coordinates inside faces
bpy.ops.mesh.uvs_reverse()
# Rotate UV coordinates inside faces
bpy.ops.mesh.uvs_rotate(use_ccw=False)
# Connect 2 vertices of a face by an edge, splitting the face in two
bpy.ops.mesh.vert_connect()
# Add vertex color layer
bpy.ops.mesh.vertex_color_add()
# Remove vertex color layer
bpy.ops.mesh.vertex_color_remove()
# Flatten angles of selected vertices
bpy.ops.mesh.vertices_smooth(repeat=1, xaxis=True, yaxis=True, zaxis=True)
# Laplacian smooth of selected vertices
bpy.ops.mesh.vertices_smooth_laplacian(repeat=1, lambda_factor=5e-05, lambda_border=5e-05, use_x=True, use_y=True, use_z=True, preserve_volume=True)
# Inset new faces into selected faces
bpy.ops.mesh.wireframe(use_boundary=True, use_even_offset=True, use_relative_offset=False, use_crease=False, thickness=0.01, use_replace=True)
# Synchronize the length of the referenced Action with the length used in the strip
bpy.ops.nla.action_sync_length(active=True)
# Add an Action-Clip strip (i.e. an NLA Strip referencing an Action) to the active track
bpy.ops.nla.actionclip_add(action=’<UNKNOWN ENUM>’)
# Apply scaling of selected strips to their referenced Actions
bpy.ops.nla.apply_scale()
# Bake object/pose loc/scale/rotation animation to a new action
bpy.ops.nla.bake(frame_start=1, frame_end=250, step=1, only_selected=True, clear_constraints=False, clear_parents=False, bake_types={‘POSE’})
# Handle clicks to select NLA channels
bpy.ops.nla.channels_click(extend=False)
# Reset scaling of selected strips
bpy.ops.nla.clear_scale()
# Handle clicks to select NLA Strips
bpy.ops.nla.click_select(extend=False)
# Delete selected strips
bpy.ops.nla.delete()
# Duplicate selected NLA-Strips, adding the new strips in new tracks above the originals
bpy.ops.nla.duplicate(mode=’TRANSLATION’)
# Add a F-Modifier of the specified type to the selected NLA-Strips
bpy.ops.nla.fmodifier_add(type=’NULL’, only_active=False)
# Copy the F-Modifier(s) of the active NLA-Strip
bpy.ops.nla.fmodifier_copy()
# Add copied F-Modifiers to the selected NLA-Strips
bpy.ops.nla.fmodifier_paste()
# Add new meta-strips incorporating the selected strips
bpy.ops.nla.meta_add()
# Separate out the strips held by the selected meta-strips
bpy.ops.nla.meta_remove()
# Move selected strips down a track if there’s room
bpy.ops.nla.move_down()
# Move selected strips up a track if there’s room
bpy.ops.nla.move_up()
# Mute or un-mute selected strips
bpy.ops.nla.mute_toggle()
# Toggle display properties panel
bpy.ops.nla.properties()
# Select or deselect all NLA-Strips
bpy.ops.nla.select_all_toggle(invert=False)
# Use box selection to grab NLA-Strips
bpy.ops.nla.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True, axis_range=False)
# Select strips to the left or the right of the current frame
bpy.ops.nla.select_leftright(mode=’CHECK’, extend=False)
# Make selected objects appear in NLA Editor by adding Animation Data
bpy.ops.nla.selected_objects_add()
# Move start of strips to specified time
bpy.ops.nla.snap(type=’CFRA’)
# Add a strip for controlling when speaker plays its sound clip
bpy.ops.nla.soundclip_add()
# Split selected strips at their midpoints
bpy.ops.nla.split()
# Swap order of selected strips within tracks
bpy.ops.nla.swap()
# Add NLA-Tracks above/after the selected tracks
bpy.ops.nla.tracks_add(above_selected=False)
# Delete selected NLA-Tracks and the strips they contain
bpy.ops.nla.tracks_delete()
# Add a transition strip between two adjacent selected strips
bpy.ops.nla.transition_add()
# Enter tweaking mode for the action referenced by the active strip
bpy.ops.nla.tweakmode_enter()
# Exit tweaking mode for the action referenced by the active strip
bpy.ops.nla.tweakmode_exit()
# Reset viewable area to show full strips range
bpy.ops.nla.view_all()
# Reset viewable area to show selected strips range
bpy.ops.nla.view_selected()
# Add a node to the active tree and link to an existing socket
bpy.ops.node.add_and_link_node(use_transform=False, settings=[], type=””, link_socket_index=0)
# Add a file node to the current node editor
bpy.ops.node.add_file(filepath=””, filter_blender=False, filter_backup=False, filter_image=True, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’, name=”Image”)
# Add a node to the active tree
bpy.ops.node.add_node(use_transform=False, settings=[], type=””)
# Add a reroute node
bpy.ops.node.add_reroute(path=[], cursor=6)
# Add a node to the active tree
bpy.ops.node.add_search(use_transform=False, settings=[], type=””, node_item=’<UNKNOWN ENUM>’)
# Attach active node to a frame
bpy.ops.node.attach()
# Move Node backdrop
bpy.ops.node.backimage_move()
# Use mouse to sample background image
bpy.ops.node.backimage_sample()
# Zoom in/out the background image
bpy.ops.node.backimage_zoom(factor=1.2)
# Copies selected nodes to the clipboard
bpy.ops.node.clipboard_copy()
# Pastes nodes from the clipboard to the active node tree
bpy.ops.node.clipboard_paste()
# Toggle collapsed nodes and hide unused sockets
bpy.ops.node.collapse_hide_unused_toggle()
# Delete selected nodes
bpy.ops.node.delete()
# Delete nodes; will reconnect nodes as if deletion was muted
bpy.ops.node.delete_reconnect()
# Detach selected nodes from parents
bpy.ops.node.detach()
# Detach nodes, move and attach to frame
bpy.ops.node.detach_translate_attach(NODE_OT_detach={}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False}, NODE_OT_attach={})
# Duplicate selected nodes
bpy.ops.node.duplicate(keep_inputs=False)
# Duplicate selected nodes and move them
bpy.ops.node.duplicate_move(NODE_OT_duplicate={“keep_inputs”:False}, NODE_OT_translate_attach={“TRANSFORM_OT_translate”:{“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False}, “NODE_OT_attach”:{}})
# Duplicate selected nodes keeping input links and move them
bpy.ops.node.duplicate_move_keep_inputs(NODE_OT_duplicate={“keep_inputs”:False}, NODE_OT_translate_attach={“TRANSFORM_OT_translate”:{“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False}, “NODE_OT_attach”:{}})
# Search for named node and allow to select and activate it
bpy.ops.node.find_node(prev=False)
# Edit node group
bpy.ops.node.group_edit(exit=False)
# Insert selected nodes into a node group
bpy.ops.node.group_insert()
# Make group from selected nodes
bpy.ops.node.group_make()
# Separate selected nodes from the node group
bpy.ops.node.group_separate(type=’COPY’)
# Ungroup selected nodes
bpy.ops.node.group_ungroup()
# Toggle unused node socket display
bpy.ops.node.hide_socket_toggle()
# Toggle hiding of selected nodes
bpy.ops.node.hide_toggle()
# Attach selected nodes to a new common frame
bpy.ops.node.join()
# Use the mouse to create a link between two nodes
bpy.ops.node.link(detach=False)
# Makes a link between selected output in input sockets
bpy.ops.node.link_make(replace=False)
# Link to viewer node
bpy.ops.node.link_viewer()
# Use the mouse to cut (remove) some links
bpy.ops.node.links_cut(path=[], cursor=9)
# Remove all links to selected nodes, and try to connect neighbor nodes together
bpy.ops.node.links_detach()
# Move a node to detach links
bpy.ops.node.move_detach_links(NODE_OT_links_detach={}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Move a node to detach links
bpy.ops.node.move_detach_links_release(NODE_OT_links_detach={}, NODE_OT_translate_attach={“TRANSFORM_OT_translate”:{“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False}, “NODE_OT_attach”:{}})
# Toggle muting of the nodes
bpy.ops.node.mute_toggle()
# Create a new node tree
bpy.ops.node.new_node_tree(type=’CompositorNodeTree’, name=”NodeTree”)
# Add a Node Color Preset
bpy.ops.node.node_color_preset_add(remove_active=False, name=””)
# Copy color to all selected nodes
bpy.ops.node.node_copy_color()
# Toggle option buttons display for selected nodes
bpy.ops.node.options_toggle()
# Add a new input to a file output node
bpy.ops.node.output_file_add_socket(file_path=”Image”)
# Move the active input of a file output node up or down the list
bpy.ops.node.output_file_move_active_socket(direction=’DOWN’)
# Remove active input from a file output node
bpy.ops.node.output_file_remove_active_socket()
# Detach selected nodes
bpy.ops.node.parent_clear()
# Attach selected nodes
bpy.ops.node.parent_set()
# Toggle preview display for selected nodes
bpy.ops.node.preview_toggle()
# Toggles the properties panel display
bpy.ops.node.properties()
# Read all render layers of current scene, in full sample
bpy.ops.node.read_fullsamplelayers()
# Read all render layers of all used scenes
bpy.ops.node.read_renderlayers()
# Render current scene, when input node’s layer has been changed
bpy.ops.node.render_changed()
# Resize a node
bpy.ops.node.resize()
# Select the node under the cursor
bpy.ops.node.select(mouse_x=0, mouse_y=0, extend=False)
# (De)select all nodes
bpy.ops.node.select_all(action=’TOGGLE’)
# Use box selection to select nodes
bpy.ops.node.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True, tweak=False)
# Select nodes using lasso selection
bpy.ops.node.select_lasso(path=[], deselect=False, extend=True)
# Select node and link it to a viewer node
bpy.ops.node.select_link_viewer(NODE_OT_select={“mouse_x”:0, “mouse_y”:0, “extend”:False}, NODE_OT_link_viewer={})
# Select nodes linked from the selected ones
bpy.ops.node.select_linked_from()
# Select nodes linked to the selected ones
bpy.ops.node.select_linked_to()
# Select all the nodes of the same type
bpy.ops.node.select_same_type()
# Activate and view same node type, step by step
bpy.ops.node.select_same_type_step(prev=False)
# Update shader script node with new sockets and options from the script
bpy.ops.node.shader_script_update()
# Sort the nodes and show the cyclic dependencies between the nodes
bpy.ops.node.show_cyclic_dependencies()
# Toggles tool shelf display
bpy.ops.node.toolbar()
# Move nodes and attach to frame
bpy.ops.node.translate_attach(TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False}, NODE_OT_attach={})
# Go to parent node tree
bpy.ops.node.tree_path_parent()
# Add an input or output socket to the current node tree
bpy.ops.node.tree_socket_add(in_out=’IN’)
# Move a socket up or down in the current node tree’s sockets stack
bpy.ops.node.tree_socket_move(direction=’UP’)
# Remove an input or output socket to the current node tree
bpy.ops.node.tree_socket_remove()
# Resize view so you can see all nodes
bpy.ops.node.view_all()
# Resize view so you can see selected nodes
bpy.ops.node.view_selected()
# Set the boundaries for viewer operations
bpy.ops.node.viewer_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Add an object to the scene
bpy.ops.object.add(type=’EMPTY’, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Add named object
bpy.ops.object.add_named(linked=False, name=”Cube”)
# Align Objects
bpy.ops.object.align(bb_quality=True, align_mode=’OPT_2’, relative_to=’OPT_4’, align_axis=set())
# Convert object animation for normal transforms to delta transforms
bpy.ops.object.anim_transforms_to_deltas()
# Add an armature object to the scene
bpy.ops.object.armature_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Bake image textures of selected objects
bpy.ops.object.bake_image()
# Add a camera object to the scene
bpy.ops.object.camera_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Add a constraint to the active object
bpy.ops.object.constraint_add(type=’<UNKNOWN ENUM>’)
# Add a constraint to the active object, with target (where applicable) set to the selected Objects/Bones
bpy.ops.object.constraint_add_with_targets(type=’<UNKNOWN ENUM>’)
# Clear all the constraints for the active Object only
bpy.ops.object.constraints_clear()
# Copy constraints to other selected objects
bpy.ops.object.constraints_copy()
# Convert selected objects to another type
bpy.ops.object.convert(target=’MESH’, keep_original=False)
# Delete selected objects
bpy.ops.object.delete(use_global=False)
# Add an empty image type to scene with data
bpy.ops.object.drop_named_image(filepath=””, name=””, view_align=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
#
bpy.ops.object.drop_named_material(name=”Material”)
# Set offset used for DupliGroup based on cursor position
bpy.ops.object.dupli_offset_from_cursor(group=0)
# Duplicate selected objects
bpy.ops.object.duplicate(linked=False, mode=’TRANSLATION’)
# Duplicate selected objects and move them
bpy.ops.object.duplicate_move(OBJECT_OT_duplicate={“linked”:False, “mode”:’TRANSLATION’}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Duplicate selected objects and move them
bpy.ops.object.duplicate_move_linked(OBJECT_OT_duplicate={“linked”:False, “mode”:’TRANSLATION’}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Make dupli objects attached to this object real
bpy.ops.object.duplicates_make_real(use_base_parent=False, use_hierarchy=False)
# Toggle object’s editmode
bpy.ops.object.editmode_toggle()
# Add an empty object with a physics effector to the scene
bpy.ops.object.effector_add(type=’FORCE’, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Add an empty object to the scene
bpy.ops.object.empty_add(type=’PLAIN_AXES’, view_align=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Refresh data in the Explode modifier
bpy.ops.object.explode_refresh(modifier=””)
# Toggle object’s force field
bpy.ops.object.forcefield_toggle()
# Copy game physics properties to other selected objects
bpy.ops.object.game_physics_copy()
# Remove all game properties from all selected objects
bpy.ops.object.game_property_clear()
# Copy/merge/replace a game property from active object to all selected objects
bpy.ops.object.game_property_copy(operation=’COPY’, property=’<UNKNOWN ENUM>’)
# Create a new property available to the game engine
bpy.ops.object.game_property_new(type=’FLOAT’, name=””)
# Remove game property
bpy.ops.object.game_property_remove(index=0)
# Add an object to a new group
bpy.ops.object.group_add()
# Add a dupligroup instance
bpy.ops.object.group_instance_add(name=”Group”, group=’<UNKNOWN ENUM>’, view_align=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Add an object to an existing group
bpy.ops.object.group_link(group=’<UNKNOWN ENUM>’)
# Remove the active object from this group
bpy.ops.object.group_remove()
# Reveal the render object by setting the hide render flag
bpy.ops.object.hide_render_clear()
# Reveal all render objects by setting the hide render flag
bpy.ops.object.hide_render_clear_all()
# Hide the render object by setting the hide render flag
bpy.ops.object.hide_render_set(unselected=False)
# Reveal the object by setting the hide flag
bpy.ops.object.hide_view_clear()
# Hide the object by setting the hide flag
bpy.ops.object.hide_view_set(unselected=False)
# Hook selected vertices to the first selected Object
bpy.ops.object.hook_add_newob()
# Hook selected vertices to the first selected Object
bpy.ops.object.hook_add_selob(use_bone=False)
# Assign the selected vertices to a hook
bpy.ops.object.hook_assign(modifier=’<UNKNOWN ENUM>’)
# Set hook center to cursor position
bpy.ops.object.hook_recenter(modifier=’<UNKNOWN ENUM>’)
# Remove a hook from the active object
bpy.ops.object.hook_remove(modifier=’<UNKNOWN ENUM>’)
# Recalculate and clear offset transformation
bpy.ops.object.hook_reset(modifier=’<UNKNOWN ENUM>’)
# Select affected vertices on mesh
bpy.ops.object.hook_select(modifier=’<UNKNOWN ENUM>’)
# Hide unselected render objects of same type as active by setting the hide render flag
bpy.ops.object.isolate_type_render()
# Join selected objects into active object
bpy.ops.object.join()
# Merge selected objects to shapes of active object
bpy.ops.object.join_shapes()
# Transfer UV Layouts from active to selected objects (needs matching geometry)
bpy.ops.object.join_uvs()
# Add a lamp object to the scene
bpy.ops.object.lamp_add(type=’POINT’, view_align=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Clear the object’s location
bpy.ops.object.location_clear()
# Copy logic bricks to other selected objects
bpy.ops.object.logic_bricks_copy()
# Make linked objects into dupli-faces
bpy.ops.object.make_dupli_face()
# Make links from the active object to other selected objects
bpy.ops.object.make_links_data(type=’OBDATA’)
# Link selection to another scene
bpy.ops.object.make_links_scene(scene=’Scene’)
# Make library linked datablocks local to this file
bpy.ops.object.make_local(type=’SELECT_OBJECT’)
# Make linked data local to each object
bpy.ops.object.make_single_user(type=’SELECTED_OBJECTS’, object=False, obdata=False, material=False, texture=False, animation=False)
# Add a new material slot
bpy.ops.object.material_slot_add()
# Assign active material slot to selection
bpy.ops.object.material_slot_assign()
# Copies materials to other selected objects
bpy.ops.object.material_slot_copy()
# Deselect by active material slot
bpy.ops.object.material_slot_deselect()
# Remove the selected material slot
bpy.ops.object.material_slot_remove()
# Select by active material slot
bpy.ops.object.material_slot_select()
# Bind mesh to cage in mesh deform modifier
bpy.ops.object.meshdeform_bind(modifier=””)
# Add an metaball object to the scene
bpy.ops.object.metaball_add(type=’BALL’, view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Sets the object interaction mode
bpy.ops.object.mode_set(mode=’OBJECT’, toggle=False)
# Add a modifier to the active object
bpy.ops.object.modifier_add(type=’SUBSURF’)
# Apply modifier and remove from the stack
bpy.ops.object.modifier_apply(apply_as=’DATA’, modifier=””)
# Convert particles to a mesh object
bpy.ops.object.modifier_convert(modifier=””)
# Duplicate modifier at the same position in the stack
bpy.ops.object.modifier_copy(modifier=””)
# Move modifier down in the stack
bpy.ops.object.modifier_move_down(modifier=””)
# Move modifier up in the stack
bpy.ops.object.modifier_move_up(modifier=””)
# Remove a modifier from the active object
bpy.ops.object.modifier_remove(modifier=””)
# Move the object to different layers
bpy.ops.object.move_to_layer(layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Modify the base mesh to conform to the displaced mesh
bpy.ops.object.multires_base_apply(modifier=””)
# Pack displacements from an external file
bpy.ops.object.multires_external_pack()
# Save displacements to an external file
bpy.ops.object.multires_external_save(filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=True, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, modifier=””)
# Deletes the higher resolution mesh, potential loss of detail
bpy.ops.object.multires_higher_levels_delete(modifier=””)
# Copy vertex coordinates from other object
bpy.ops.object.multires_reshape(modifier=””)
# Add a new level of subdivision
bpy.ops.object.multires_subdivide(modifier=””)
# Bake an image sequence of ocean data
bpy.ops.object.ocean_bake(modifier=””, free=False)
# Clear the object’s origin
bpy.ops.object.origin_clear()
# Set the object’s origin, by either moving the data, or set to center of data, or use 3D cursor
bpy.ops.object.origin_set(type=’GEOMETRY_ORIGIN’, center=’MEDIAN’)
# Clear the object’s parenting
bpy.ops.object.parent_clear(type=’CLEAR’)
# Set the object’s parenting without setting the inverse parent correction
bpy.ops.object.parent_no_inverse_set()
# Set the object’s parenting
bpy.ops.object.parent_set(type=’OBJECT’, xmirror=False, keep_transform=False)
# Add a particle system
bpy.ops.object.particle_system_add()
# Remove the selected particle system
bpy.ops.object.particle_system_remove()
# Calculate motion paths for the selected objects
bpy.ops.object.paths_calculate(start_frame=1, end_frame=250)
# Clear path caches for selected objects
bpy.ops.object.paths_clear()
# Recalculate paths for selected objects
bpy.ops.object.paths_update()
# Enable or disable posing/selecting bones
bpy.ops.object.posemode_toggle()
# Add empty object to become local replacement data of a library-linked object
bpy.ops.object.proxy_make(object=’DEFAULT’)
#
bpy.ops.object.quick_explode(style=’EXPLODE’, amount=100, frame_duration=50, frame_start=1, frame_end=10, velocity=1, fade=True)
#
bpy.ops.object.quick_fluid(style=’BASIC’, initial_velocity=(0, 0, 0), show_flows=False, start_baking=False)
#
bpy.ops.object.quick_fur(density=’MEDIUM’, view_percentage=10, length=0.1)
#
bpy.ops.object.quick_smoke(style=’STREAM’, show_flows=False)
# Randomize objects loc/rot/scale
bpy.ops.object.randomize_transform(random_seed=0, use_delta=False, use_loc=True, loc=(0, 0, 0), use_rot=True, rot=(0, 0, 0), use_scale=True, scale_even=False, scale=(1, 1, 1))
# Clear the object’s rotation
bpy.ops.object.rotation_clear()
# Clear the object’s scale
bpy.ops.object.scale_clear()
# Change selection of all visible objects in scene
bpy.ops.object.select_all(action=’TOGGLE’)
# Select all visible objects on a layer
bpy.ops.object.select_by_layer(match=’EXACT’, extend=False, layers=1)
# Select all visible objects that are of a type
bpy.ops.object.select_by_type(extend=False, type=’MESH’)
# Select the active camera
bpy.ops.object.select_camera(extend=False)
# Select all visible objects grouped by various properties
bpy.ops.object.select_grouped(extend=False, type=’CHILDREN_RECURSIVE’)
# Select object relative to the active object’s position in the hierarchy
bpy.ops.object.select_hierarchy(direction=’PARENT’, extend=False)
# Select all visible objects that are linked
bpy.ops.object.select_linked(extend=False, type=’OBDATA’)
# Select the Mirror objects of the selected object eg. L.sword -> R.sword
bpy.ops.object.select_mirror(extend=False)
# Select objects matching a naming pattern
bpy.ops.object.select_pattern(pattern=”*”, case_sensitive=False, extend=True)
# Set select on random visible objects
bpy.ops.object.select_random(percent=50, extend=False)
# Select object in the same group
bpy.ops.object.select_same_group(group=””)
# Render and display faces uniform, using Face Normals
bpy.ops.object.shade_flat()
# Render and display faces smooth, using interpolated Vertex Normals
bpy.ops.object.shade_smooth()
# Add shape key to the object
bpy.ops.object.shape_key_add(from_mix=True)
# Clear weights for all shape keys
bpy.ops.object.shape_key_clear()
# Mirror the current shape key along the local X axis
bpy.ops.object.shape_key_mirror(use_topology=False)
# Move the active shape key up/down in the list
bpy.ops.object.shape_key_move(type=’UP’)
# Remove shape key from the object
bpy.ops.object.shape_key_remove(all=False)
# Resets the timing for absolute shape keys
bpy.ops.object.shape_key_retime()
# Copy another selected objects active shape to this one by applying the relative offsets
bpy.ops.object.shape_key_transfer(mode=’OFFSET’, use_clamp=False)
# Create an armature that parallels the skin layout
bpy.ops.object.skin_armature_create(modifier=””)
# Mark/clear selected vertices as loose
bpy.ops.object.skin_loose_mark_clear(action=’MARK’)
# Make skin radii of selected vertices equal on each axis
bpy.ops.object.skin_radii_equalize()
# Mark selected vertices as roots
bpy.ops.object.skin_root_mark()
# Clear the object’s slow parent
bpy.ops.object.slow_parent_clear()
# Set the object’s slow parent
bpy.ops.object.slow_parent_set()
# Add a speaker object to the scene
bpy.ops.object.speaker_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Sets a Subdivision Surface Level (1-5)
bpy.ops.object.subdivision_set(level=1, relative=False)
# Add a text object to the scene
bpy.ops.object.text_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Clear tracking constraint or flag from object
bpy.ops.object.track_clear(type=’CLEAR’)
# Make the object track another object, either by constraint or old way or locked track
bpy.ops.object.track_set(type=’DAMPTRACK’)
# Apply the object’s transformation to its data
bpy.ops.object.transform_apply(location=False, rotation=False, scale=False)
# Add a new vertex group to the active object
bpy.ops.object.vertex_group_add()
# Assign the selected vertices to the active vertex group
bpy.ops.object.vertex_group_assign()
# Assign the selected vertices to a new vertex group
bpy.ops.object.vertex_group_assign_new()
# Blend selected vertex weights with unselected for the active group
bpy.ops.object.vertex_group_blend(factor=1)
# Remove Vertex Group assignments which aren’t required
bpy.ops.object.vertex_group_clean(group_select_mode=’ACTIVE’, limit=0, keep_single=False)
# Make a copy of the active vertex group
bpy.ops.object.vertex_group_copy()
# Copy Vertex Groups to all users of the same Geometry data
bpy.ops.object.vertex_group_copy_to_linked()
# Copy Vertex Groups to other selected objects with matching indices
bpy.ops.object.vertex_group_copy_to_selected()
# Deselect all selected vertices assigned to the active vertex group
bpy.ops.object.vertex_group_deselect()
# Modify the position of selected vertices by changing only their respective groups’ weights (this tool may be slow for many vertices)
bpy.ops.object.vertex_group_fix(dist=0, strength=1, accuracy=1)
# Invert active vertex group’s weights
bpy.ops.object.vertex_group_invert(group_select_mode=’ACTIVE’, auto_assign=True, auto_remove=True)
# Add some offset and multiply with some gain the weights of the active vertex group
bpy.ops.object.vertex_group_levels(group_select_mode=’ACTIVE’, offset=0, gain=1)
# Limit deform weights associated with a vertex to a specified number by removing lowest weights
bpy.ops.object.vertex_group_limit_total(group_select_mode=’ALL’, limit=4)
# Change the lock state of all vertex groups of active object
bpy.ops.object.vertex_group_lock(action=’TOGGLE’)
# Mirror all vertex groups, flip weights and/or names, editing only selected vertices, flipping when both sides are selected otherwise copy from unselected
bpy.ops.object.vertex_group_mirror(mirror_weights=True, flip_group_names=True, all_groups=False, use_topology=False)
# Move the active vertex group up/down in the list
bpy.ops.object.vertex_group_move(direction=’UP’)
# Normalize weights of the active vertex group, so that the highest ones are now 1.0
bpy.ops.object.vertex_group_normalize()
# Normalize all weights of all vertex groups, so that for each vertex, the sum of all weights is 1.0
bpy.ops.object.vertex_group_normalize_all(lock_active=True)
# Delete the active vertex group
bpy.ops.object.vertex_group_remove(all=False)
# Remove the selected vertices from active or all vertex group(s)
bpy.ops.object.vertex_group_remove_from(use_all_groups=False, use_all_verts=False)
# Select all the vertices assigned to the active vertex group
bpy.ops.object.vertex_group_select()
# Set the active vertex group
bpy.ops.object.vertex_group_set_active(group=’<UNKNOWN ENUM>’)
# Sorts vertex groups alphabetically
bpy.ops.object.vertex_group_sort()
# Transfer weight paint to active from selected mesh
bpy.ops.object.vertex_group_transfer_weight(WT_vertex_group_mode=’WT_REPLACE_ACTIVE_VERTEX_GROUP’, WT_method=’WT_BY_NEAREST_FACE’, WT_replace_mode=’WT_REPLACE_ALL_WEIGHTS’)
# Parent selected objects to the selected vertices
bpy.ops.object.vertex_parent_set()
# Copy weights from Active to selected
bpy.ops.object.vertex_weight_copy()
# Delete this weight from the vertex (disabled if vertex Group is locked)
bpy.ops.object.vertex_weight_delete(weight_group=-1)
# Normalize Active Vert Weights
bpy.ops.object.vertex_weight_normalize_active_vertex()
# Copy this group’s weight to other selected verts (disabled if vertex Group is locked)
bpy.ops.object.vertex_weight_paste(weight_group=-1)
# Set as active Vertex Group
bpy.ops.object.vertex_weight_set_active(weight_group=-1)
# Apply the object’s visual transformation to its data
bpy.ops.object.visual_transform_apply()
# Change the active action used
bpy.ops.outliner.action_set(action=’<UNKNOWN ENUM>’)
#
bpy.ops.outliner.animdata_operation(type=’SET_ACT’)
#
bpy.ops.outliner.data_operation(type=’SELECT’)
# Add drivers to selected items
bpy.ops.outliner.drivers_add_selected()
# Delete drivers assigned to selected items
bpy.ops.outliner.drivers_delete_selected()
# Expand/Collapse all items
bpy.ops.outliner.expanded_toggle()
#
bpy.ops.outliner.group_operation(type=’UNLINK’)
#
bpy.ops.outliner.id_operation(type=’UNLINK’)
# Handle mouse clicks to activate/select items
bpy.ops.outliner.item_activate(extend=True, recursive=False)
# Toggle whether item under cursor is enabled or closed
bpy.ops.outliner.item_openclose(all=True)
# Rename item under cursor
bpy.ops.outliner.item_rename()
# Add selected items (blue-gray rows) to active Keying Set
bpy.ops.outliner.keyingset_add_selected()
# Remove selected items (blue-gray rows) from active Keying Set
bpy.ops.outliner.keyingset_remove_selected()
# Drag material to object in Outliner
bpy.ops.outliner.material_drop(object=”Object”, material=”Material”)
#
bpy.ops.outliner.object_operation(type=’SELECT’)
# Context menu for item operations
bpy.ops.outliner.operation()
# Drag to clear parent in Outliner
bpy.ops.outliner.parent_clear(dragged_obj=”Object”, type=’CLEAR’)
# Drag to parent in Outliner
bpy.ops.outliner.parent_drop(child=”Object”, parent=”Object”, type=’OBJECT’)
# Toggle the renderability of selected items
bpy.ops.outliner.renderability_toggle()
# Drag object to scene in Outliner
bpy.ops.outliner.scene_drop(object=”Object”, scene=”Scene”)
# Scroll page up or down
bpy.ops.outliner.scroll_page(up=False)
# Use box selection to select tree elements
bpy.ops.outliner.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0)
# Toggle the selectability
bpy.ops.outliner.selectability_toggle()
# Toggle the Outliner selection of items
bpy.ops.outliner.selected_toggle()
# Adjust the view so that the active Object is shown centered
bpy.ops.outliner.show_active()
# Open all object entries and close all others
bpy.ops.outliner.show_hierarchy()
# Expand/collapse all entries by one level
bpy.ops.outliner.show_one_level(open=True)
# Toggle the visibility of selected items
bpy.ops.outliner.visibility_toggle()
# Select a paint mode’s brush by tool type
bpy.ops.paint.brush_select(paint_mode=’ACTIVE’, sculpt_tool=’BLOB’, vertex_paint_tool=’MIX’, weight_paint_tool=’MIX’, texture_paint_tool=’DRAW’, toggle=False, create_missing=False)
# Change selection for all faces
bpy.ops.paint.face_select_all(action=’TOGGLE’)
# Hide selected faces
bpy.ops.paint.face_select_hide(unselected=False)
# Select linked faces
bpy.ops.paint.face_select_linked()
# Select linked faces
bpy.ops.paint.face_select_linked_pick(extend=False)
# Reveal hidden faces
bpy.ops.paint.face_select_reveal(unselected=False)
# Move the clone source image
bpy.ops.paint.grab_clone(delta=(0, 0))
# Hide/show some vertices
bpy.ops.paint.hide_show(action=’HIDE’, area=’INSIDE’, xmin=0, xmax=0, ymin=0, ymax=0)
# Make an image from the current 3D view for re-projection
bpy.ops.paint.image_from_view(filepath=””)
# Paint a stroke into the image
bpy.ops.paint.image_paint(mode=’NORMAL’, stroke=[])
# Fill the whole mask with a given value, or invert its values
bpy.ops.paint.mask_flood_fill(mode=’VALUE’, value=0)
# Project an edited render from the active camera back onto the object
bpy.ops.paint.project_image(image=’Render Result’)
# Use the mouse to sample a color in the image
bpy.ops.paint.sample_color(location=(0, 0))
# Toggle texture paint mode in 3D view
bpy.ops.paint.texture_paint_toggle()
# Change selection for all vertices
bpy.ops.paint.vert_select_all(action=’TOGGLE’)
# Select vertices without a group
bpy.ops.paint.vert_select_ungrouped(extend=False)
#
bpy.ops.paint.vertex_color_dirt(blur_strength=1, blur_iterations=1, clean_angle=3.14159, dirt_angle=0, dirt_only=False)
# Fill the active vertex color layer with the current paint color
bpy.ops.paint.vertex_color_set()
# Smooth colors across vertices
bpy.ops.paint.vertex_color_smooth()
# Paint a stroke in the active vertex color layer
bpy.ops.paint.vertex_paint(stroke=[])
# Toggle the vertex paint mode in 3D view
bpy.ops.paint.vertex_paint_toggle()
# Set the weights of the groups matching the attached armature’s selected bones, using the distance between the vertices and the bones
bpy.ops.paint.weight_from_bones(type=’AUTOMATIC’)
# Sample a line and show it in Scope panels
bpy.ops.paint.weight_gradient(type=’LINEAR’, xstart=0, xend=0, ystart=0, yend=0, cursor=1)
# Paint a stroke in the current vertex group’s weights
bpy.ops.paint.weight_paint(stroke=[])
# Toggle weight paint mode in 3D view
bpy.ops.paint.weight_paint_toggle()
# Use the mouse to sample a weight in the 3D view
bpy.ops.paint.weight_sample()
# Select one of the vertex groups available under current mouse position
bpy.ops.paint.weight_sample_group(group=’<UNKNOWN ENUM>’)
# Fill the active vertex group with the current paint weight
bpy.ops.paint.weight_set()
# Apply a stroke of brush to the particles
bpy.ops.particle.brush_edit(stroke=[])
# Connect hair to the emitter mesh
bpy.ops.particle.connect_hair(all=False)
# Delete selected particles or keys
bpy.ops.particle.delete(type=’PARTICLE’)
# Disconnect hair from the emitter mesh
bpy.ops.particle.disconnect_hair(all=False)
# Duplicate the current dupliobject
bpy.ops.particle.dupliob_copy()
# Move dupli object down in the list
bpy.ops.particle.dupliob_move_down()
# Move dupli object up in the list
bpy.ops.particle.dupliob_move_up()
# Remove the selected dupliobject
bpy.ops.particle.dupliob_remove()
# Undo all edition performed on the particle system
bpy.ops.particle.edited_clear()
# Hide selected particles
bpy.ops.particle.hide(unselected=False)
# Duplicate and mirror the selected particles along the local X axis
bpy.ops.particle.mirror()
# Add new particle settings
bpy.ops.particle.new()
# Add a new particle target
bpy.ops.particle.new_target()
# Toggle particle edit mode
bpy.ops.particle.particle_edit_toggle()
# Change the number of keys of selected particles (root and tip keys included)
bpy.ops.particle.rekey(keys_number=2)
# Remove selected particles close enough of others
bpy.ops.particle.remove_doubles(threshold=0.0002)
# Show hidden particles
bpy.ops.particle.reveal()
# (De)select all particles’ keys
bpy.ops.particle.select_all(action=’TOGGLE’)
# Deselect boundary selected keys of each particle
bpy.ops.particle.select_less()
# Select nearest particle from mouse pointer
bpy.ops.particle.select_linked(deselect=False, location=(0, 0))
# Select keys linked to boundary selected keys of each particle
bpy.ops.particle.select_more()
# Select roots of all visible particles
bpy.ops.particle.select_roots(action=’SELECT’)
# Select tips of all visible particles
bpy.ops.particle.select_tips(action=’SELECT’)
# Subdivide selected particles segments (adds keys)
bpy.ops.particle.subdivide()
# Move particle target down in the list
bpy.ops.particle.target_move_down()
# Move particle target up in the list
bpy.ops.particle.target_move_up()
# Remove the selected particle target
bpy.ops.particle.target_remove()
# Set the weight of selected keys
bpy.ops.particle.weight_set(factor=1)
# Apply the current pose as the new rest pose
bpy.ops.pose.armature_apply()
# Change the visible armature layers
bpy.ops.pose.armature_layers(layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Automatically renames the selected bones according to which side of the target axis they fall on
bpy.ops.pose.autoside_names(axis=’XAXIS’)
# Change the layers that the selected bones belong to
bpy.ops.pose.bone_layers(layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Create a suitable breakdown pose on the current frame
bpy.ops.pose.breakdown(prev_frame=0, next_frame=0, percentage=0.5)
# Add a constraint to the active bone
bpy.ops.pose.constraint_add(type=’<UNKNOWN ENUM>’)
# Add a constraint to the active bone, with target (where applicable) set to the selected Objects/Bones
bpy.ops.pose.constraint_add_with_targets(type=’<UNKNOWN ENUM>’)
# Clear all the constraints for the selected bones
bpy.ops.pose.constraints_clear()
# Copy constraints to other selected bones
bpy.ops.pose.constraints_copy()
# Copies the current pose of the selected bones to copy/paste buffer
bpy.ops.pose.copy()
# Flips (and corrects) the axis suffixes of the the names of selected bones
bpy.ops.pose.flip_names()
# Add a new bone group
bpy.ops.pose.group_add()
# Add selected bones to the chosen bone group
bpy.ops.pose.group_assign(type=0)
# Deselect bones of active Bone Group
bpy.ops.pose.group_deselect()
# Change position of active Bone Group in list of Bone Groups
bpy.ops.pose.group_move(direction=’UP’)
# Remove the active bone group
bpy.ops.pose.group_remove()
# Select bones in active Bone Group
bpy.ops.pose.group_select()
# Sort Bone Groups by their names in ascending order
bpy.ops.pose.group_sort()
# Remove selected bones from all bone groups
bpy.ops.pose.group_unassign()
# Tag selected bones to not be visible in Pose Mode
bpy.ops.pose.hide(unselected=False)
# Add IK Constraint to the active Bone
bpy.ops.pose.ik_add(with_targets=True)
# Remove all IK Constraints from selected bones
bpy.ops.pose.ik_clear()
# Reset locations of selected bones to their default values
bpy.ops.pose.loc_clear()
# Paste the stored pose on to the current pose
bpy.ops.pose.paste(flipped=False, selected_mask=False)
# Calculate paths for the selected bones
bpy.ops.pose.paths_calculate(start_frame=1, end_frame=250, bake_location=’TAILS’)
# Clear path caches for selected bones
bpy.ops.pose.paths_clear()
# Recalculate paths for bones that already have them
bpy.ops.pose.paths_update()
# Copy selected aspects of the current pose to subsequent poses already keyframed
bpy.ops.pose.propagate(mode=’WHILE_HELD’, end_frame=250)
# Exaggerate the current pose
bpy.ops.pose.push(prev_frame=0, next_frame=0, percentage=0.5)
# Flip quaternion values to achieve desired rotations, while maintaining the same orientations
bpy.ops.pose.quaternions_flip()
# Make the current pose more similar to its surrounding ones
bpy.ops.pose.relax(prev_frame=0, next_frame=0, percentage=0.5)
# Unhide all bones that have been tagged to be hidden in Pose Mode
bpy.ops.pose.reveal()
# Reset rotations of selected bones to their default values
bpy.ops.pose.rot_clear()
# Set the rotation representation used by selected bones
bpy.ops.pose.rotation_mode_set(type=’QUATERNION’)
# Reset scaling of selected bones to their default values
bpy.ops.pose.scale_clear()
# Toggle selection status of all bones
bpy.ops.pose.select_all(action=’TOGGLE’)
# Select bones used as targets for the currently selected bones
bpy.ops.pose.select_constraint_target()
# Activate the bone with a flipped name
bpy.ops.pose.select_flip_active()
# Select all visible bones grouped by similar properties
bpy.ops.pose.select_grouped(extend=False, type=’LAYER’)
# Select immediate parent/children of selected bones
bpy.ops.pose.select_hierarchy(direction=’PARENT’, extend=False)
# Select bones related to selected ones by parent/child relationships
bpy.ops.pose.select_linked(extend=False)
# Select bones that are parents of the currently selected bones
bpy.ops.pose.select_parent()
# Reset location, rotation, and scaling of selected bones to their default values
bpy.ops.pose.transforms_clear()
# Reset pose on selected bones to keyframed state
bpy.ops.pose.user_transforms_clear(only_selected=True)
# Apply final constrained position of pose bones to their transform
bpy.ops.pose.visual_transform_apply()
# Make action suitable for use as a Pose Library
bpy.ops.poselib.action_sanitize()
# Apply specified Pose Library pose to the rig
bpy.ops.poselib.apply_pose(pose_index=-1)
# Interactively browse poses in 3D-View
bpy.ops.poselib.browse_interactive(pose_index=-1)
# Add New Pose Library to active Object
bpy.ops.poselib.new()
# Add the current Pose to the active Pose Library
bpy.ops.poselib.pose_add(frame=1, name=”Pose”)
# Remove nth pose from the active Pose Library
bpy.ops.poselib.pose_remove(pose=’<UNKNOWN ENUM>’)
# Rename specified pose from the active Pose Library
bpy.ops.poselib.pose_rename(name=”RenamedPose”, pose=’<UNKNOWN ENUM>’)
# Remove Pose Library from active Object
bpy.ops.poselib.unlink()
# Add new cache
bpy.ops.ptcache.add()
# Bake physics
bpy.ops.ptcache.bake(bake=False)
# Bake all physics
bpy.ops.ptcache.bake_all(bake=True)
# Bake from cache
bpy.ops.ptcache.bake_from_cache()
# Free physics bake
bpy.ops.ptcache.free_bake()
# Free all baked caches of all objects in the current scene
bpy.ops.ptcache.free_bake_all()
# Delete current cache
bpy.ops.ptcache.remove()
# Add an Integrator Preset
bpy.ops.render.cycles_integrator_preset_add(remove_active=False, name=””)
# OpenGL render active viewport
bpy.ops.render.opengl(animation=False, sequencer=False, write_still=False, view_context=True)
# Play back rendered frames/movies using an external player
bpy.ops.render.play_rendered_anim()
# Add a Render Preset
bpy.ops.render.preset_add(remove_active=False, name=””)
# Render active scene
bpy.ops.render.render(animation=False, write_still=False, layer=””, scene=””)
# Cancel show render view
bpy.ops.render.view_cancel()
# Toggle show render view
bpy.ops.render.view_show()
# Bake rigid body transformations of selected objects to keyframes
bpy.ops.rigidbody.bake_to_keyframes(frame_start=1, frame_end=250, step=1)
# Create rigid body constraints between selected rigid bodies
bpy.ops.rigidbody.connect(con_type=’FIXED’, pivot_type=’CENTER’, connection_pattern=’SELECTED_TO_ACTIVE’)
# Add Rigid Body Constraint to active object
bpy.ops.rigidbody.constraint_add(type=’FIXED’)
# Remove Rigid Body Constraint from Object
bpy.ops.rigidbody.constraint_remove()
# Automatically calculate mass values for Rigid Body Objects based on volume
bpy.ops.rigidbody.mass_calculate(material=’Air’, density=1)
# Add active object as Rigid Body
bpy.ops.rigidbody.object_add(type=’ACTIVE’)
# Remove Rigid Body settings from Object
bpy.ops.rigidbody.object_remove()
# Copy Rigid Body settings from active object to selected
bpy.ops.rigidbody.object_settings_copy()
# Add selected objects as Rigid Bodies
bpy.ops.rigidbody.objects_add(type=’ACTIVE’)
# Remove selected objects from Rigid Body simulation
bpy.ops.rigidbody.objects_remove()
# Change collision shapes for selected Rigid Body Objects
bpy.ops.rigidbody.shape_change(type=’MESH’)
# Add Rigid Body simulation world to the current scene
bpy.ops.rigidbody.world_add()
# Remove Rigid Body simulation world from the current scene
bpy.ops.rigidbody.world_remove()
# Delete active scene
bpy.ops.scene.delete()
# Add the data paths to the Freestyle Edge Mark property of selected edges to the active keying set
bpy.ops.scene.freestyle_add_edge_marks_to_keying_set()
# Add the data paths to the Freestyle Face Mark property of selected polygons to the active keying set
bpy.ops.scene.freestyle_add_face_marks_to_keying_set()
# Add an alpha transparency modifier to the line style associated with the active lineset
bpy.ops.scene.freestyle_alpha_modifier_add(type=’ALONG_STROKE’)
# Add a line color modifier to the line style associated with the active lineset
bpy.ops.scene.freestyle_color_modifier_add(type=’ALONG_STROKE’)
# Fill the Range Min/Max entries by the min/max distance between selected mesh objects and the source object
bpy.ops.scene.freestyle_fill_range_by_selection(type=’COLOR’, name=””)
# Add a stroke geometry modifier to the line style associated with the active lineset
bpy.ops.scene.freestyle_geometry_modifier_add(type=‘2D_OFFSET’)
# Add a line set into the list of line sets
bpy.ops.scene.freestyle_lineset_add()
# Copy the active line set to a buffer
bpy.ops.scene.freestyle_lineset_copy()
# Change the position of the active line set within the list of line sets
bpy.ops.scene.freestyle_lineset_move(direction=’UP’)
# Paste the buffer content to the active line set
bpy.ops.scene.freestyle_lineset_paste()
# Remove the active line set from the list of line sets
bpy.ops.scene.freestyle_lineset_remove()
# Create a new line style, reusable by multiple line sets
bpy.ops.scene.freestyle_linestyle_new()
# Duplicate the modifier within the list of modifiers
bpy.ops.scene.freestyle_modifier_copy()
# Move the modifier within the list of modifiers
bpy.ops.scene.freestyle_modifier_move(direction=’UP’)
# Remove the modifier from the list of modifiers
bpy.ops.scene.freestyle_modifier_remove()
# Add a style module into the list of modules
bpy.ops.scene.freestyle_module_add()
# Change the position of the style module within in the list of style modules
bpy.ops.scene.freestyle_module_move(direction=’UP’)
# Open a style module file
bpy.ops.scene.freestyle_module_open(filepath=””, make_internal=True)
# Remove the style module from the stack
bpy.ops.scene.freestyle_module_remove()
# Add a line thickness modifier to the line style associated with the active lineset
bpy.ops.scene.freestyle_thickness_modifier_add(type=’ALONG_STROKE’)
# Add new scene by type
bpy.ops.scene.new(type=’NEW’)
# Add a render layer
bpy.ops.scene.render_layer_add()
# Remove the selected render layer
bpy.ops.scene.render_layer_remove()
# Handle area action zones for mouse actions/gestures
bpy.ops.screen.actionzone(modifier=0)
# Cancel animation, returning to the original frame
bpy.ops.screen.animation_cancel(restore_frame=True)
# Play animation
bpy.ops.screen.animation_play(reverse=False, sync=False)
# Step through animation by position
bpy.ops.screen.animation_step()
# Duplicate selected area into new window
bpy.ops.screen.area_dupli()
# Join selected areas into new window
bpy.ops.screen.area_join(min_x=-100, min_y=-100, max_x=-100, max_y=-100)
# Move selected area edges
bpy.ops.screen.area_move(x=0, y=0, delta=0)
# Operations for splitting and merging
bpy.ops.screen.area_options()
# Split selected area into new windows
bpy.ops.screen.area_split(direction=’HORIZONTAL’, factor=0.5, mouse_x=-100, mouse_y=-100)
# Swap selected areas screen positions
bpy.ops.screen.area_swap()
# Revert back to the original screen layout, before fullscreen area overlay
bpy.ops.screen.back_to_previous()
# Delete active screen
bpy.ops.screen.delete()
# Jump to first/last frame in frame range
bpy.ops.screen.frame_jump(end=False)
# Move current frame forward/backward by a given number
bpy.ops.screen.frame_offset(delta=0)
# Toggle the header over/below the main window area
bpy.ops.screen.header_flip()
# Show or hide the header pulldown menus
bpy.ops.screen.header_toggle_menus()
# Display header region toolbox
bpy.ops.screen.header_toolbox()
# Jump to previous/next keyframe
bpy.ops.screen.keyframe_jump(next=True)
# Add a new screen
bpy.ops.screen.new()
# Display menu for last action performed
bpy.ops.screen.redo_last()
# Blend in and out overlapping region
bpy.ops.screen.region_blend()
# Toggle the region’s alignment (left/right or top/bottom)
bpy.ops.screen.region_flip()
# Split selected area into camera, front, right & top views
bpy.ops.screen.region_quadview()
# Scale selected area
bpy.ops.screen.region_scale()
# Display menu for previous actions performed
bpy.ops.screen.repeat_history(index=0)
# Repeat last action
bpy.ops.screen.repeat_last()
# Toggle display selected area as fullscreen
bpy.ops.screen.screen_full_area()
# Cycle through available screens
bpy.ops.screen.screen_set(delta=0)
# Capture a video of the active area or whole Blender window
bpy.ops.screen.screencast(filepath=””, full=True)
# Capture a picture of the active area or whole Blender window
bpy.ops.screen.screenshot(filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=True, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’, full=True)
# Remove unused settings for invisible editors
bpy.ops.screen.spacedata_cleanup()
# Show user preferences
bpy.ops.screen.userpref_show()
# Ignore autoexec warning
bpy.ops.script.autoexec_warn_clear()
# Execute a preset
bpy.ops.script.execute_preset(filepath=””, menu_idname=””)
# Run Python file
bpy.ops.script.python_file_run(filepath=””)
# Reload Scripts
bpy.ops.script.reload()
# Sculpt a stroke into the geometry
bpy.ops.sculpt.brush_stroke(stroke=[], mode=’NORMAL’, ignore_background_click=False)
# Dynamic topology alters the mesh topology while sculpting
bpy.ops.sculpt.dynamic_topology_toggle()
# Recalculate the sculpt BVH to improve performance
bpy.ops.sculpt.optimize()
# Toggle sculpt mode in 3D view
bpy.ops.sculpt.sculptmode_toggle()
# Reset the copy of the mesh that is being sculpted on
bpy.ops.sculpt.set_persistent_base()
# Symmetrize the topology modifications
bpy.ops.sculpt.symmetrize()
# Sculpt UVs using a brush
bpy.ops.sculpt.uv_sculpt_stroke(mode=’NORMAL’)
#
bpy.ops.sequencer.change_effect_input(swap=’A_B’)
#
bpy.ops.sequencer.change_effect_type(type=’CROSS’)
#
bpy.ops.sequencer.change_path(filepath=””, directory=””, files=[], filter_blender=False, filter_backup=False, filter_image=True, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’)
#
bpy.ops.sequencer.copy()
# Do cross-fading volume animation of two selected sound strips
bpy.ops.sequencer.crossfade_sounds()
# Cut the selected strips
bpy.ops.sequencer.cut(frame=0, type=’SOFT’, side=’BOTH’)
# Cut multi-cam strip and select camera
bpy.ops.sequencer.cut_multicam(camera=1)
# Deinterlace all selected movie sources
bpy.ops.sequencer.deinterlace_selected_movies()
# Erase selected strips from the sequencer
bpy.ops.sequencer.delete()
# Duplicate the selected strips
bpy.ops.sequencer.duplicate(mode=’TRANSLATION’)
# Duplicate selected strips and move them
bpy.ops.sequencer.duplicate_move(SEQUENCER_OT_duplicate={“mode”:’TRANSLATION’}, TRANSFORM_OT_translate={“value”:(0, 0, 0), “constraint_axis”:(False, False, False), “constraint_orientation”:’GLOBAL’, “mirror”:False, “proportional”:’DISABLED’, “proportional_edit_falloff”:’SMOOTH’, “proportional_size”:1, “snap”:False, “snap_target”:’CLOSEST’, “snap_point”:(0, 0, 0), “snap_align”:False, “snap_normal”:(0, 0, 0), “texture_space”:False, “release_confirm”:False})
# Add an effect to the sequencer, most are applied on top of existing strips
bpy.ops.sequencer.effect_strip_add(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=False, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, frame_start=0, frame_end=0, channel=1, replace_sel=True, overlap=False, type=’CROSS’, color=(0, 0, 0))
# Insert gap at current frame to first strips at the right, independent of selection or locked state of strips
bpy.ops.sequencer.gap_insert(frames=10)
# Remove gap at current frame to first strip at the right, independent of selection or locked state of strips
bpy.ops.sequencer.gap_remove(all=False)
# Add an image or image sequence to the sequencer
bpy.ops.sequencer.image_strip_add(directory=””, files=[], filter_blender=False, filter_backup=False, filter_image=True, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, frame_start=0, frame_end=0, channel=1, replace_sel=True, overlap=False)
# On image sequence strips, it returns a strip for each image
bpy.ops.sequencer.images_separate(length=1)
# Lock the active strip so that it can’t be transformed
bpy.ops.sequencer.lock()
# Add a mask strip to the sequencer
bpy.ops.sequencer.mask_strip_add(frame_start=0, channel=1, replace_sel=True, overlap=False, mask=’<UNKNOWN ENUM>’)
# Group selected strips into a metastrip
bpy.ops.sequencer.meta_make()
# Put the contents of a metastrip back in the sequencer
bpy.ops.sequencer.meta_separate()
# Toggle a metastrip (to edit enclosed strips)
bpy.ops.sequencer.meta_toggle()
# Add a movie strip to the sequencer
bpy.ops.sequencer.movie_strip_add(filepath=””, files=[], filter_blender=False, filter_backup=False, filter_image=False, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, frame_start=0, channel=1, replace_sel=True, overlap=False, sound=True)
# Add a movieclip strip to the sequencer
bpy.ops.sequencer.movieclip_strip_add(frame_start=0, channel=1, replace_sel=True, overlap=False, clip=’<UNKNOWN ENUM>’)
# Mute selected strips
bpy.ops.sequencer.mute(unselected=False)
# Clear strip offsets from the start and end frames
bpy.ops.sequencer.offset_clear()
#
bpy.ops.sequencer.paste()
# Open sequencer properties panel
bpy.ops.sequencer.properties()
# Reassign the inputs for the effect strip
bpy.ops.sequencer.reassign_inputs()
# Rebuild all selected proxies and timecode indices using the job system
bpy.ops.sequencer.rebuild_proxy()
# Refresh the sequencer editor
bpy.ops.sequencer.refresh_all()
# Reload strips in the sequencer
bpy.ops.sequencer.reload(adjust_length=False)
# Set render size and aspect from active sequence
bpy.ops.sequencer.rendersize()
# Use mouse to sample color in current frame
bpy.ops.sequencer.sample()
# Add a strip to the sequencer using a blender scene as a source
bpy.ops.sequencer.scene_strip_add(frame_start=0, channel=1, replace_sel=True, overlap=False, scene=’Scene’)
# Select a strip (last selected becomes the “active strip”)
bpy.ops.sequencer.select(extend=False, linked_handle=False, left_right=False, linked_time=False)
# Select strips on the nominated side of the active strip
bpy.ops.sequencer.select_active_side(side=’BOTH’)
# Select or deselect all strips
bpy.ops.sequencer.select_all(action=’TOGGLE’)
# Enable border select mode
bpy.ops.sequencer.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select all strips grouped by various properties
bpy.ops.sequencer.select_grouped(extend=False, type=’TYPE’)
# Select manipulator handles on the sides of the selected strip
bpy.ops.sequencer.select_handles(side=’BOTH’)
# Shrink the current selection of adjacent selected strips
bpy.ops.sequencer.select_less()
# Select all strips adjacent to the current selection
bpy.ops.sequencer.select_linked()
# Select a chain of linked strips nearest to the mouse pointer
bpy.ops.sequencer.select_linked_pick(extend=False)
# Select more strips adjacent to the current selection
bpy.ops.sequencer.select_more()
# Frame where selected strips will be snapped
bpy.ops.sequencer.snap(frame=0)
# Add a sound strip to the sequencer
bpy.ops.sequencer.sound_strip_add(filepath=””, files=[], filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=True, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, frame_start=0, channel=1, replace_sel=True, overlap=False, cache=False)
# Move frame to previous edit point
bpy.ops.sequencer.strip_jump(next=True, center=True)
# Add a modifier to strip
bpy.ops.sequencer.strip_modifier_add(type=’COLOR_BALANCE’)
# Move modifier up and down in the stack
bpy.ops.sequencer.strip_modifier_move(name=”Name”, direction=’UP’)
# Add a modifier to strip
bpy.ops.sequencer.strip_modifier_remove(name=”Name”)
# Swap active strip with strip to the right or left
bpy.ops.sequencer.swap(side=’RIGHT’)
# Swap 2 sequencer strips
bpy.ops.sequencer.swap_data()
# Swap the first two inputs for the effect strip
bpy.ops.sequencer.swap_inputs()
# Unlock the active strip so that it can’t be transformed
bpy.ops.sequencer.unlock()
# Un-Mute unselected rather than selected strips
bpy.ops.sequencer.unmute(unselected=False)
# View all the strips in the sequencer
bpy.ops.sequencer.view_all()
# Zoom preview to fit in the area
bpy.ops.sequencer.view_all_preview()
# Enable border select mode
bpy.ops.sequencer.view_ghost_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0)
# Zoom the sequencer on the selected strips
bpy.ops.sequencer.view_selected()
# Toggle between sequencer views (sequence, preview, both)
bpy.ops.sequencer.view_toggle()
# Change zoom ratio of sequencer preview
bpy.ops.sequencer.view_zoom_ratio(ratio=1)
# Cancel the current sketch stroke
bpy.ops.sketch.cancel_stroke()
# Convert the selected sketch strokes to bone chains
bpy.ops.sketch.convert()
# Delete a sketch stroke
bpy.ops.sketch.delete()
# Draw preview of current sketch stroke (internal use)
bpy.ops.sketch.draw_preview(snap=False)
# Start to draw a sketch stroke
bpy.ops.sketch.draw_stroke(snap=False)
# End and keep the current sketch stroke
bpy.ops.sketch.finish_stroke()
# Start to draw a gesture stroke
bpy.ops.sketch.gesture(snap=False)
# Select a sketch stroke
bpy.ops.sketch.select()
# Update the audio animation cache
bpy.ops.sound.bake_animation()
# Mixes the scene’s audio to a sound file
bpy.ops.sound.mixdown(filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=True, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, accuracy=1024, container=’FLAC’, codec=’FLAC’, format=’S16’, bitrate=192, split_channels=False)
# Load a sound file
bpy.ops.sound.open(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=True, filter_python=False, filter_font=False, filter_sound=True, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, cache=False, mono=False)
# Load a sound file as mono
bpy.ops.sound.open_mono(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=True, filter_python=False, filter_font=False, filter_sound=True, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, cache=False, mono=True)
# Pack the sound into the current blend file
bpy.ops.sound.pack()
# Unpack the sound to the samples filename
bpy.ops.sound.unpack(method=’USE_LOCAL’, id=””)
# Update animation flags
bpy.ops.sound.update_animation_flags()
# Construct a Nurbs surface Circle
bpy.ops.surface.primitive_nurbs_surface_circle_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs surface Curve
bpy.ops.surface.primitive_nurbs_surface_curve_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs surface Cylinder
bpy.ops.surface.primitive_nurbs_surface_cylinder_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs surface Sphere
bpy.ops.surface.primitive_nurbs_surface_sphere_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs surface Patch
bpy.ops.surface.primitive_nurbs_surface_surface_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Construct a Nurbs surface Torus
bpy.ops.surface.primitive_nurbs_surface_torus_add(view_align=False, enter_editmode=False, location=(0, 0, 0), rotation=(0, 0, 0), layers=(False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False))
# Show a list of used text in the open document
bpy.ops.text.autocomplete()
# Convert selected text to comment
bpy.ops.text.comment()
# Convert whitespaces by type
bpy.ops.text.convert_whitespace(type=’SPACES’)
# Copy selected text to clipboard
bpy.ops.text.copy()
# Set cursor position
bpy.ops.text.cursor_set(x=0, y=0)
# Cut selected text to clipboard
bpy.ops.text.cut()
# Delete text by cursor position
bpy.ops.text.delete(type=’NEXT_CHARACTER’)
# Duplicate the current line
bpy.ops.text.duplicate_line()
# Find specified text
bpy.ops.text.find()
# Find specified text and set as selected
bpy.ops.text.find_set_selected()
# Indent selected text
bpy.ops.text.indent()
# Insert text at cursor position
bpy.ops.text.insert(text=””)
# Jump cursor to line
bpy.ops.text.jump(line=1)
# Insert line break at cursor position
bpy.ops.text.line_break()
# The current line number
bpy.ops.text.line_number()
# Make active text file internal
bpy.ops.text.make_internal()
# Move cursor to position type
bpy.ops.text.move(type=’LINE_BEGIN’)
# Move the currently selected line(s) up/down
bpy.ops.text.move_lines(direction=’DOWN’)
# Make selection from current cursor position to new cursor position type
bpy.ops.text.move_select(type=’LINE_BEGIN’)
# Create a new text data block
bpy.ops.text.new()
# Open a new text data block
bpy.ops.text.open(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=True, filter_font=False, filter_sound=False, filter_text=True, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’, internal=False)
# Toggle overwrite while typing
bpy.ops.text.overwrite_toggle()
# Paste text from clipboard
bpy.ops.text.paste(selection=False)
# Toggle text properties panel
bpy.ops.text.properties()
# Refresh all pyconstraints
bpy.ops.text.refresh_pyconstraints()
# Reload active text data block from its file
bpy.ops.text.reload()
# Replace text with the specified text
bpy.ops.text.replace()
# Replace text with specified text and set as selected
bpy.ops.text.replace_set_selected()
# When external text is out of sync, resolve the conflict
bpy.ops.text.resolve_conflict(resolution=’IGNORE’)
# Run active script
bpy.ops.text.run_script()
# Save active text data block
bpy.ops.text.save()
# Save active text file with options
bpy.ops.text.save_as(filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=True, filter_font=False, filter_sound=False, filter_text=True, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’)
# Scroll text screen
bpy.ops.text.scroll(lines=1)
# Scroll text screen
bpy.ops.text.scroll_bar(lines=1)
# Select all text
bpy.ops.text.select_all()
# Select text by line
bpy.ops.text.select_line()
# Select word under cursor
bpy.ops.text.select_word()
# Set cursor selection
bpy.ops.text.selection_set(select=False)
# Start searching text
bpy.ops.text.start_find()
# Create 3D text object from active text data block
bpy.ops.text.to_3d_object(split_lines=False)
# Convert selected comment to text
bpy.ops.text.uncomment()
# Unindent selected text
bpy.ops.text.unindent()
# Unlink active text data block
bpy.ops.text.unlink()
# Discard the environment map and free it from memory
bpy.ops.texture.envmap_clear()
# Discard all environment maps in the .blend file and free them from memory
bpy.ops.texture.envmap_clear_all()
# Save the current generated Environment map to an image file
bpy.ops.texture.envmap_save(layout=(0, 0, 1, 0, 2, 0, 0, 1, 1, 1, 2, 1), filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=True, filter_movie=True, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=9, display_type=’FILE_DEFAULTDISPLAY’)
# Add a new texture
bpy.ops.texture.new()
# Copy the material texture settings and nodes
bpy.ops.texture.slot_copy()
# Move texture slots up and down
bpy.ops.texture.slot_move(type=’UP’)
# Copy the texture settings and nodes
bpy.ops.texture.slot_paste()
# Set the end frame
bpy.ops.time.end_frame_set()
# Set the start frame
bpy.ops.time.start_frame_set()
# Show the entire playable frame range
bpy.ops.time.view_all()
# Create transformation orientation from selection
bpy.ops.transform.create_orientation(name=””, use_view=False, use=False, overwrite=False)
# Delete transformation orientation
bpy.ops.transform.delete_orientation()
# Change the bevel weight of edges
bpy.ops.transform.edge_bevelweight(value=0, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Change the crease of edges
bpy.ops.transform.edge_crease(value=0, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Slide an edge loop along a mesh
bpy.ops.transform.edge_slide(value=0, mirror=False, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), correct_uv=False, release_confirm=False)
# Mirror selected vertices around one or more axes
bpy.ops.transform.mirror(constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, release_confirm=False)
# Push/Pull selected items
bpy.ops.transform.push_pull(value=0, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Scale (resize) selected items
bpy.ops.transform.resize(value=(1, 1, 1), constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), texture_space=False, release_confirm=False)
# Rotate selected items
bpy.ops.transform.rotate(value=0, axis=(0, 0, 0), constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Select transformation orientation
bpy.ops.transform.select_orientation(orientation=’GLOBAL’)
# Slide a sequence strip in time
bpy.ops.transform.seq_slide(value=(0, 0), snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Shear selected items along the horizontal screen axis
bpy.ops.transform.shear(value=0, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Shrink/fatten selected vertices along normals
bpy.ops.transform.shrink_fatten(value=0, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Scale selected vertices’ skin radii
bpy.ops.transform.skin_resize(value=(1, 1, 1), constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), texture_space=False, release_confirm=False)
# Tilt selected control vertices of 3D curve
bpy.ops.transform.tilt(value=0, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Move selected vertices outward in a spherical shape around mesh center
bpy.ops.transform.tosphere(value=0, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Trackball style rotation of selected items
bpy.ops.transform.trackball(value=(0, 0), mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Transform selected items by mode type
bpy.ops.transform.transform(mode=’TRANSLATION’, value=(0, 0, 0, 0), axis=(0, 0, 0), constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Translate (move) selected items
bpy.ops.transform.translate(value=(0, 0, 0), constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), texture_space=False, release_confirm=False)
# Slide a vertex along a mesh
bpy.ops.transform.vert_slide(value=0, mirror=False, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Warp selected items around the cursor
bpy.ops.transform.warp(value=(0,), mirror=False, proportional=’DISABLED’, proportional_edit_falloff=’SMOOTH’, proportional_size=1, snap=False, snap_target=’CLOSEST’, snap_point=(0, 0, 0), snap_align=False, snap_normal=(0, 0, 0), release_confirm=False)
# Copy the RNA data path for this property to the clipboard
bpy.ops.ui.copy_data_path_button()
# Copy property from this object to selected objects or bones
bpy.ops.ui.copy_to_selected_button(all=True)
# Edit UI source code of the active button
bpy.ops.ui.editsource()
# Edit i18n in current language for the active button
bpy.ops.ui.edittranslation_init()
# Sample a color from the Blender Window to store in a property
bpy.ops.ui.eyedropper()
# Force a full reload of UI translation
bpy.ops.ui.reloadtranslation()
# Write the reports
bpy.ops.ui.reports_to_textblock()
# Reset this property’s value to its default value
bpy.ops.ui.reset_default_button(all=True)
# Reset to the default theme colors
bpy.ops.ui.reset_default_theme()
# Align selected UV vertices to an axis
bpy.ops.uv.align(axis=’ALIGN_AUTO’)
# Average the size of separate UV islands, based on their area in 3D space
bpy.ops.uv.average_islands_scale()
# Select UV vertices using circle selection
bpy.ops.uv.circle_select(x=0, y=0, radius=0, gesture_mode=0)
# Project the UV vertices of the mesh over the six faces of a cube
bpy.ops.uv.cube_project(cube_size=1, correct_aspect=True, clip_to_bounds=False, scale_to_bounds=False)
# Set 2D cursor location
bpy.ops.uv.cursor_set(location=(0, 0))
# Project the UV vertices of the mesh over the curved wall of a cylinder
bpy.ops.uv.cylinder_project(direction=’VIEW_ON_EQUATOR’, align=’POLAR_ZX’, radius=1, correct_aspect=True, clip_to_bounds=False, scale_to_bounds=False)
# Export UV layout to file
bpy.ops.uv.export_layout(filepath=””, check_existing=True, export_all=False, modified=False, mode=’PNG’, size=(1024, 1024), opacity=0.25, tessellated=False)
# Follow UVs from active quads along continuous face loops
bpy.ops.uv.follow_active_quads(mode=’LENGTH_AVERAGE’)
# Hide (un)selected UV vertices
bpy.ops.uv.hide(unselected=False)
# Follow UVs from active quads along continuous face loops
bpy.ops.uv.lightmap_pack(PREF_CONTEXT=’SEL_FACES’, PREF_PACK_IN_ONE=True, PREF_NEW_UVLAYER=False, PREF_APPLY_IMAGE=False, PREF_IMG_PX_SIZE=512, PREF_BOX_DIV=12, PREF_MARGIN_DIV=0.1)
# Mark selected UV edges as seams
bpy.ops.uv.mark_seam()
# Reduce UV stretching by relaxing angles
bpy.ops.uv.minimize_stretch(fill_holes=True, blend=0, iterations=0)
# Transform all islands so that they fill up the UV space as much as possible
bpy.ops.uv.pack_islands(margin=0.001)
# Set/clear selected UV vertices as anchored between multiple unwrap operations
bpy.ops.uv.pin(clear=False)
# Project the UV vertices of the mesh as seen in current 3D view
bpy.ops.uv.project_from_view(orthographic=False, camera_bounds=True, correct_aspect=True, clip_to_bounds=False, scale_to_bounds=False)
# Selected UV vertices that are within a radius of each other are welded together
bpy.ops.uv.remove_doubles(threshold=0.02, use_unselected=False)
# Reset UV projection
bpy.ops.uv.reset()
# Reveal all hidden UV vertices
bpy.ops.uv.reveal()
# Set mesh seams according to island setup in the UV editor
bpy.ops.uv.seams_from_islands(mark_seams=True, mark_sharp=False)
# Select UV vertices
bpy.ops.uv.select(extend=False, location=(0, 0))
# Change selection of all UV vertices
bpy.ops.uv.select_all(action=’TOGGLE’)
# Select UV vertices using border selection
bpy.ops.uv.select_border(pinned=False, gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select UVs using lasso selection
bpy.ops.uv.select_lasso(path=[], deselect=False, extend=True)
# Deselect UV vertices at the boundary of each selection region
bpy.ops.uv.select_less()
# Select all UV vertices linked to the active UV map
bpy.ops.uv.select_linked(extend=False)
# Select all UV vertices linked under the mouse
bpy.ops.uv.select_linked_pick(extend=False, location=(0, 0))
# Select a loop of connected UV vertices
bpy.ops.uv.select_loop(extend=False, location=(0, 0))
# Select more UV vertices connected to initial selection
bpy.ops.uv.select_more()
# Select all pinned UV vertices
bpy.ops.uv.select_pinned()
# Select only entirely selected faces
bpy.ops.uv.select_split()
# This script projection unwraps the selected faces of a mesh (it operates on all selected mesh objects, and can be used to unwrap selected faces, or all faces)
bpy.ops.uv.smart_project(angle_limit=66, island_margin=0, user_area_weight=0)
# Snap cursor to target type
bpy.ops.uv.snap_cursor(target=’PIXELS’)
# Snap selected UV vertices to target type
bpy.ops.uv.snap_selected(target=’PIXELS’)
# Project the UV vertices of the mesh over the curved surface of a sphere
bpy.ops.uv.sphere_project(direction=’VIEW_ON_EQUATOR’, align=’POLAR_ZX’, correct_aspect=True, clip_to_bounds=False, scale_to_bounds=False)
# Stitch selected UV vertices by proximity
bpy.ops.uv.stitch(use_limit=False, snap_islands=True, limit=0.01, static_island=0, midpoint_snap=False, clear_seams=True, mode=’VERTEX’, stored_mode=’VERTEX’, selection=[])
# Set UV image tile coordinates
bpy.ops.uv.tile_set(tile=(0, 0))
# Unwrap the mesh of the object being edited
bpy.ops.uv.unwrap(method=’ANGLE_BASED’, fill_holes=True, correct_aspect=True, use_subsurf_data=False, margin=0.001)
# Weld selected UV vertices together
bpy.ops.uv.weld()
# Pan the view
bpy.ops.view2d.pan(deltax=0, deltay=0)
# Reset the view
bpy.ops.view2d.reset()
# Scroll the view down
bpy.ops.view2d.scroll_down(deltax=0, deltay=0, page=False)
# Scroll the view left
bpy.ops.view2d.scroll_left(deltax=0, deltay=0)
# Scroll the view right
bpy.ops.view2d.scroll_right(deltax=0, deltay=0)
# Scroll the view up
bpy.ops.view2d.scroll_up(deltax=0, deltay=0, page=False)
# Scroll view by mouse click and drag
bpy.ops.view2d.scroller_activate()
# Zoom in the view to the nearest item contained in the border
bpy.ops.view2d.smoothview(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0)
# Zoom in/out the view
bpy.ops.view2d.zoom(deltax=0, deltay=0)
# Zoom in the view to the nearest item contained in the border
bpy.ops.view2d.zoom_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0)
# Zoom in the view
bpy.ops.view2d.zoom_in(zoomfacx=0, zoomfacy=0)
# Zoom out the view
bpy.ops.view2d.zoom_out(zoomfacx=0, zoomfacy=0)
# Add a new background image
bpy.ops.view3d.background_image_add(name=”Image”, filepath=”Path”)
# Remove a background image from the 3D view
bpy.ops.view3d.background_image_remove(index=0)
# Set camera view to active view
bpy.ops.view3d.camera_to_view()
# Move the camera so selected objects are framed
bpy.ops.view3d.camera_to_view_selected()
# Clear the boundaries of the border render and disable border render
bpy.ops.view3d.clear_render_border()
# Set the view clipping border
bpy.ops.view3d.clip_border(xmin=0, xmax=0, ymin=0, ymax=0)
# Selected objects are saved in a temp file
bpy.ops.view3d.copybuffer()
# Set the location of the 3D cursor
bpy.ops.view3d.cursor3d()
# Dolly in/out in the view
bpy.ops.view3d.dolly(delta=0, mx=0, my=0)
# Extrude individual elements and move
bpy.ops.view3d.edit_mesh_extrude_individual_move()
# Extrude and move along normals
bpy.ops.view3d.edit_mesh_extrude_move_normal()
# Enable the transform manipulator for use
bpy.ops.view3d.enable_manipulator(translate=False, rotate=False, scale=False)
# Interactively fly around the scene
bpy.ops.view3d.fly()
# Start game engine
bpy.ops.view3d.game_start()
# Toggle layer(s) visibility
bpy.ops.view3d.layers(nr=1, extend=False, toggle=True)
# Toggle display of selected object(s) separately and centered in view
bpy.ops.view3d.localview()
# Manipulate selected item by axis
bpy.ops.view3d.manipulator(constraint_axis=(False, False, False), constraint_orientation=’GLOBAL’, release_confirm=False)
# Move the view
bpy.ops.view3d.move()
# Position your viewpoint with the 3D mouse
bpy.ops.view3d.ndof_all()
# Explore every angle of an object using the 3D mouse
bpy.ops.view3d.ndof_orbit()
# Explore every angle of an object using the 3D mouse
bpy.ops.view3d.ndof_orbit_zoom()
# Position your viewpoint with the 3D mouse
bpy.ops.view3d.ndof_pan()
# Set the active object as the active camera for this view or scene
bpy.ops.view3d.object_as_camera()
# Contents of copy buffer gets pasted
bpy.ops.view3d.pastebuffer()
# Toggles the properties panel display
bpy.ops.view3d.properties()
# Set the boundaries of the border render and enable border render
bpy.ops.view3d.render_border(xmin=0, xmax=0, ymin=0, ymax=0, camera_only=False)
# Rotate the view
bpy.ops.view3d.rotate()
# Interactive ruler
bpy.ops.view3d.ruler()
# Activate/select item(s)
bpy.ops.view3d.select(extend=False, deselect=False, toggle=False, center=False, enumerate=False, object=False, location=(0, 0))
# Select items using border selection
bpy.ops.view3d.select_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0, extend=True)
# Select items using circle selection
bpy.ops.view3d.select_circle(x=0, y=0, radius=0, gesture_mode=0)
# Select items using lasso selection
bpy.ops.view3d.select_lasso(path=[], deselect=False, extend=True)
# Menu object selection
bpy.ops.view3d.select_menu(name=’<UNKNOWN ENUM>’, toggle=False)
# Select element under the mouse, deselect everything is there’s nothing under the mouse
bpy.ops.view3d.select_or_deselect_all(extend=False, toggle=False, deselect=False, center=False, enumerate=False, object=False)
# The time to animate the change of view (in milliseconds)
bpy.ops.view3d.smoothview()
# Snap cursor to active item
bpy.ops.view3d.snap_cursor_to_active()
# Snap cursor to the Center
bpy.ops.view3d.snap_cursor_to_center()
# Snap cursor to nearest grid node
bpy.ops.view3d.snap_cursor_to_grid()
# Snap cursor to center of selected item(s)
bpy.ops.view3d.snap_cursor_to_selected()
# Snap selected item(s) to cursor
bpy.ops.view3d.snap_selected_to_cursor()
# Snap selected item(s) to nearest grid node
bpy.ops.view3d.snap_selected_to_grid()
# Toggles tool shelf display
bpy.ops.view3d.toolshelf()
# View all objects in scene
bpy.ops.view3d.view_all(use_all_regions=False, center=False)
# Center the camera view
bpy.ops.view3d.view_center_camera()
# Center the view so that the cursor is in the middle of the view
bpy.ops.view3d.view_center_cursor()
# Center the view to the Z-depth position under the mouse cursor
bpy.ops.view3d.view_center_pick()
# Clear all view locking
bpy.ops.view3d.view_lock_clear()
# Lock the view to the active object/bone
bpy.ops.view3d.view_lock_to_active()
# Orbit the view
bpy.ops.view3d.view_orbit(type=’ORBITLEFT’)
# Pan the view
bpy.ops.view3d.view_pan(type=’PANLEFT’)
# Switch the current view from perspective/orthographic projection
bpy.ops.view3d.view_persportho()
# Move the view to the selection center
bpy.ops.view3d.view_selected(use_all_regions=False)
# Use a preset viewpoint
bpy.ops.view3d.viewnumpad(type=’FRONT’, align_active=False)
# Zoom in/out in the view
bpy.ops.view3d.zoom(delta=0, mx=0, my=0)
# Zoom in the view to the nearest object contained in the border
bpy.ops.view3d.zoom_border(gesture_mode=0, xmin=0, xmax=0, ymin=0, ymax=0)
# Match the camera to 1:1 to the render output
bpy.ops.view3d.zoom_camera_1_to_1()
# Disable an addon
bpy.ops.wm.addon_disable(module=””)
# Enable an addon
bpy.ops.wm.addon_enable(module=””)
# Display more information on this addon
bpy.ops.wm.addon_expand(module=””)
# Install an addon
bpy.ops.wm.addon_install(overwrite=True, target=’DEFAULT’, filepath=””, filter_folder=True, filter_python=True, filter_glob=”.py;.zip”)
# Disable an addon
bpy.ops.wm.addon_remove(module=””)
#
bpy.ops.wm.appconfig_activate(filepath=””)
#
bpy.ops.wm.appconfig_default()
# Launch the blender-player with the current blend-file
bpy.ops.wm.blenderplayer_start()
# Call (draw) a pre-defined menu
bpy.ops.wm.call_menu(name=””)
# Save a Collada file
bpy.ops.wm.collada_export(filepath=””, check_existing=True, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=True, filter_folder=True, filemode=8, display_type=’FILE_DEFAULTDISPLAY’, apply_modifiers=False, export_mesh_type=0, export_mesh_type_selection=’view’, selected=False, include_children=False, include_armatures=False, include_shapekeys=True, deform_bones_only=False, active_uv_only=False, include_uv_textures=False, include_material_textures=False, use_texture_copies=True, triangulate=True, use_object_instantiation=True, sort_by_name=False, export_transformation_type=0, export_transformation_type_selection=’matrix’, second_life=False)
# Load a Collada file
bpy.ops.wm.collada_import(filepath=””, filter_blender=False, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=True, filter_folder=True, filemode=8, display_type=’FILE_DEFAULTDISPLAY’, import_units=False)
# Set boolean values for a collection of items
bpy.ops.wm.context_collection_boolean_set(data_path_iter=””, data_path_item=””, type=’TOGGLE’)
# Set a context array value (useful for cycling the active mesh edit mode)
bpy.ops.wm.context_cycle_array(data_path=””, reverse=False)
# Toggle a context value
bpy.ops.wm.context_cycle_enum(data_path=””, reverse=False)
# Set a context value (useful for cycling active material, vertex keys, groups, etc.)
bpy.ops.wm.context_cycle_int(data_path=””, reverse=False)
#
bpy.ops.wm.context_menu_enum(data_path=””)
# Adjust arbitrary values with mouse input
bpy.ops.wm.context_modal_mouse(data_path_iter=””, data_path_item=””, header_text=””, input_scale=0.01, invert=False, initial_x=0)
# Scale an int context value
bpy.ops.wm.context_scale_int(data_path=””, value=1, always_step=True)
# Set a context value
bpy.ops.wm.context_set_boolean(data_path=””, value=True)
# Set a context value
bpy.ops.wm.context_set_enum(data_path=””, value=””)
# Set a context value
bpy.ops.wm.context_set_float(data_path=””, value=0, relative=False)
# Toggle a context value
bpy.ops.wm.context_set_id(data_path=””, value=””)
# Set a context value
bpy.ops.wm.context_set_int(data_path=””, value=0, relative=False)
# Set a context value
bpy.ops.wm.context_set_string(data_path=””, value=””)
# Set a context value
bpy.ops.wm.context_set_value(data_path=””, value=””)
# Toggle a context value
bpy.ops.wm.context_toggle(data_path=””)
# Toggle a context value
bpy.ops.wm.context_toggle_enum(data_path=””, value_1=””, value_2=””)
# Copy settings from previous version
bpy.ops.wm.copy_prev_settings()
# Open a popup to set the debug level
bpy.ops.wm.debug_menu(debug_value=0)
# Print dependency graph relations to the console
bpy.ops.wm.dependency_relations()
# Load online reference docs
bpy.ops.wm.doc_edit(doc_id=””, doc_new=””)
# Load online reference docs
bpy.ops.wm.doc_view(doc_id=””)
# Load online manual
bpy.ops.wm.doc_view_manual(doc_id=””)
# Add an Application Interaction Preset
bpy.ops.wm.interaction_preset_add(remove_active=False, name=””)
# Add a theme preset
bpy.ops.wm.interface_theme_preset_add(remove_active=False, name=””)
#
bpy.ops.wm.keyconfig_activate(filepath=””)
# Export key configuration to a python script
bpy.ops.wm.keyconfig_export(filepath=”keymap.py”, filter_folder=True, filter_text=True, filter_python=True)
# Import key configuration from a python script
bpy.ops.wm.keyconfig_import(filepath=”keymap.py”, filter_folder=True, filter_text=True, filter_python=True, keep_original=True)
# Add a Key-config Preset
bpy.ops.wm.keyconfig_preset_add(remove_active=False, name=””)
# Remove key config
bpy.ops.wm.keyconfig_remove()
# Test key-config for conflicts
bpy.ops.wm.keyconfig_test()
# Add key map item
bpy.ops.wm.keyitem_add()
# Remove key map item
bpy.ops.wm.keyitem_remove(item_id=0)
# Restore key map item
bpy.ops.wm.keyitem_restore(item_id=0)
# Restore key map(s)
bpy.ops.wm.keymap_restore(all=False)
# Link or Append from a Library .blend file
bpy.ops.wm.link_append(filepath=””, directory=””, filename=””, files=[], filter_blender=True, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=1, relative_path=True, display_type=’FILE_DEFAULTDISPLAY’, link=True, autoselect=True, active_layer=True, instance_groups=True)
# Print memory statistics to the console
bpy.ops.wm.memory_statistics()
# Change NDOF sensitivity
bpy.ops.wm.ndof_sensitivity_change(decrease=True, fast=False)
# Open a Blender file
bpy.ops.wm.open_mainfile(filepath=””, filter_blender=True, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=8, display_type=’FILE_DEFAULTDISPLAY’, load_ui=True, use_scripts=True)
#
bpy.ops.wm.operator_cheat_sheet()
# Set the active operator to its default values
bpy.ops.wm.operator_defaults()
# Add an Operator Preset
bpy.ops.wm.operator_preset_add(remove_active=False, name=””, operator=””)
# Open a path in a file browser
bpy.ops.wm.path_open(filepath=””)
#
bpy.ops.wm.properties_add(data_path=””)
# Jump to a different tab inside the properties editor
bpy.ops.wm.properties_context_change(context=””)
#
bpy.ops.wm.properties_edit(data_path=””, property=””, value=””, min=0, max=1, description=””)
# Internal use (edit a property data_path)
bpy.ops.wm.properties_remove(data_path=””, property=””)
# Quit Blender
bpy.ops.wm.quit_blender()
# Set some size property (like e.g. brush size) with mouse wheel
bpy.ops.wm.radial_control(data_path_primary=””, data_path_secondary=””, use_secondary=””, rotation_path=””, color_path=””, fill_color_path=””, zoom_path=””, image_id=””)
# Load default file and user preferences
bpy.ops.wm.read_factory_settings()
# Reloads history and bookmarks
bpy.ops.wm.read_history()
# Open the default file (doesn’t save the current file)
bpy.ops.wm.read_homefile()
# Open an automatically saved file to recover it
bpy.ops.wm.recover_auto_save(filepath=””, filter_blender=True, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=False, filemode=8, display_type=’FILE_LONGDISPLAY’)
# Open the last closed file (“quit.blend”)
bpy.ops.wm.recover_last_session()
# Simple redraw timer to test the speed of updating the interface
bpy.ops.wm.redraw_timer(type=’DRAW’, iterations=10)
# Save the current file in the desired location
bpy.ops.wm.save_as_mainfile(filepath=””, check_existing=True, filter_blender=True, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=8, display_type=’FILE_DEFAULTDISPLAY’, compress=False, relative_remap=True, copy=False, use_mesh_compat=False)
# Make the current file the default .blend file, includes preferences
bpy.ops.wm.save_homefile()
# Save the current Blender file
bpy.ops.wm.save_mainfile(filepath=””, check_existing=True, filter_blender=True, filter_backup=False, filter_image=False, filter_movie=False, filter_python=False, filter_font=False, filter_sound=False, filter_text=False, filter_btx=False, filter_collada=False, filter_folder=True, filemode=8, display_type=’FILE_DEFAULTDISPLAY’, compress=False, relative_remap=False)
# Save user preferences separately, overrides startup file preferences
bpy.ops.wm.save_userpref()
# Pop-up a search menu over all available operators in current context
bpy.ops.wm.search_menu()
# Opens a blocking popup region with release info
bpy.ops.wm.splash()
# Generate System Info
bpy.ops.wm.sysinfo()
# Load and apply a Blender XML theme file
bpy.ops.wm.theme_install(overwrite=True, filepath=””, filter_folder=True, filter_glob=”*.xml”)
# Open a website in the web-browser
bpy.ops.wm.url_open(url=””)
# (undocumented operator)
bpy.ops.wm.userpref_autoexec_path_add()
# (undocumented operator)
bpy.ops.wm.userpref_autoexec_path_remove(index=0)
# Duplicate the current Blender window
bpy.ops.wm.window_duplicate()
# Toggle the current window fullscreen
bpy.ops.wm.window_fullscreen_toggle()
# Add a new world
bpy.ops.world.new()


"""
"""
"""
def merge_objects( objects, name='_temp_', transform=None ):
	assert objects
	copies = []
	for ob in objects:
		ob.select = False
		if ob.type == 'MESH':
			o2 = ob.copy(); copies.append( o2 )
			o2.data = o2.to_mesh(bpy.context.scene, True, "PREVIEW") # collaspe modifiers
			while o2.modifiers:
				o2.modifiers.remove( o2.modifiers[0] )
			if transform:
				o2.matrix_world =  transform * o2.matrix_local
			bpy.context.scene.objects.link( o2 ) #; o2.select = True
	merged = merge( copies )
	merged.name = name
	merged.data.name = name
	return merged
########################################################################## 
def merge( objects ):
	print('MERGE', objects)
	for ob in bpy.context.selected_objects:
		ob.select = False
	for ob in objects:
		print('\t'+ob.name)
		ob.select = True
		assert not ob.library
	bpy.context.scene.objects.active = ob
	bpy.ops.object.join()
	return bpy.context.active_object
########################################################################## 
def gather_instances():
	instances = {}
	for ob in bpy.context.scene.objects:
		if ob.data and ob.data.users > 1:
			if ob.data not in instances:
				instances[ ob.data ] = []
			instances[ ob.data ].append( ob )
	return instances
"""
# Enumerate Collection-Objects 
"""
import bpy

wcol = bpy.data.collections.get("Collection 1")
if wcol:
	for i, o in enumerate(wcol.objects):
		o.name = "Water%d" % i
"""

